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'; import { assertReversalPreview, buildReversalFacts, previewSeriesReversal as planSeriesReversal, type SeriesReversalMode, type SeriesReversalPreview, } from './domain/competition-reversal'; type PersistenceId = string | mongoose.Types.ObjectId; const COMMAND_TRANSACTION_ATTEMPTS = 3; 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>; mapping: Readonly>; startedAt?: Date; durationSeconds?: number; participants?: readonly Readonly>[]; 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 PreviewSeriesReversalCommand { competitionId: PersistenceId; expectedRevision: number; seriesId: PersistenceId; mode: SeriesReversalMode; } export interface ReverseSeriesCommand extends PreviewSeriesReversalCommand { idempotencyKey: string; actor: CompetitionCommandActor; occurredAt?: Date; reason: string; impactHash: string; } export interface CompetitionCommandResult { competition: unknown; commandId: string; revision: number; replayed: boolean; } interface CommandEnvelope { type: 'accept-game' | 'adjudicate-series' | 'reverse-series'; competitionId: PersistenceId; expectedRevision: number; idempotencyKey: string; actor: CompetitionCommandActor; occurredAt?: Date; payload: Readonly>; } interface AssignmentRecord { seriesId: PersistenceId; gameSlotId: PersistenceId; tournamentCodeId: PersistenceId; state: string; } @Injectable() export class CompetitionCommandService { constructor(private readonly connectionService: ConnectionService) {} public acceptGame( command: AcceptGameCommand, ): Promise { 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.startedAt ? { startedAt: command.startedAt } : {}), ...(command.durationSeconds === undefined ? {} : { durationSeconds: command.durationSeconds }), ...(command.participants ? { participants: command.participants } : {}), ...(command.tournamentCode ? { tournamentCode: command.tournamentCode } : {}), }, }); } public adjudicateSeries( command: AdjudicateSeriesCommand, ): Promise { 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(), }, }); } public async previewSeriesReversal( command: PreviewSeriesReversalCommand, ): Promise { if ( !Number.isInteger(command.expectedRevision) || command.expectedRevision < 0 ) { throw invalidCommandError(); } const CompetitionModel = await this.connectionService.getModel('competition'); const competition = await CompetitionModel.findById(command.competitionId) .lean() .exec(); if (!competition) throw competitionNotFound(command.competitionId); assertExpectedRevision(competition.revision, command.expectedRevision); const [FactModel, AssignmentModel] = await Promise.all([ this.connectionService.getModel('competitionFact'), this.connectionService.getModel('tournamentCodeAssignment'), ]); const [facts, assignments] = await Promise.all([ FactModel.find({ competitionId: command.competitionId }) .sort({ revision: 1, ordinalWithinRevision: 1 }) .lean() .exec(), AssignmentModel.find({ competitionId: command.competitionId }) .lean() .exec() as Promise, ]); const revisionCheck = await CompetitionModel.findById(command.competitionId) .lean() .exec(); if (!revisionCheck) throw competitionNotFound(command.competitionId); assertExpectedRevision(revisionCheck.revision, command.expectedRevision); return planSeriesReversal( reversalInput(competition, command, facts, assignments), ); } public async reverseSeries( command: ReverseSeriesCommand, ): Promise { const envelope: CommandEnvelope = { type: 'reverse-series', competitionId: command.competitionId, expectedRevision: command.expectedRevision, idempotencyKey: command.idempotencyKey, actor: command.actor, occurredAt: command.occurredAt, payload: { seriesId: command.seriesId, mode: command.mode, reason: command.reason.trim(), impactHash: command.impactHash, }, }; validateEnvelope(envelope); if (!/^[a-f0-9]{64}$/.test(command.impactHash)) { throw invalidCommandError(); } let lastRetryableError: unknown; for ( let attempt = 1; attempt <= COMMAND_TRANSACTION_ATTEMPTS; attempt += 1 ) { 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, FactModel, OutboxModel, AssignmentModel] = await Promise.all([ this.connectionService.getModel('competition'), this.connectionService.getModel('competitionFact'), this.connectionService.getModel('competitionOutbox'), this.connectionService.getModel('tournamentCodeAssignment'), ]); const requestHash = requestHashFor(envelope); const commandId = commandIdFor(envelope); const receipt = await OutboxModel.findOne({ competitionId: command.competitionId, idempotencyKey: command.idempotencyKey, }) .session(session) .lean() .exec(); if (receipt) { const replay = await this.replay( CompetitionModel, command.competitionId, requestHash, receipt, session, ); await session.commitTransaction(); return replay; } const competition = await CompetitionModel.findById( command.competitionId, ) .session(session) .lean() .exec(); if (!competition) throw competitionNotFound(command.competitionId); assertExpectedRevision(competition.revision, command.expectedRevision); const [existingFacts, assignments] = await Promise.all([ FactModel.find({ competitionId: command.competitionId }) .sort({ revision: 1, ordinalWithinRevision: 1 }) .session(session) .lean() .exec(), AssignmentModel.find({ competitionId: command.competitionId }) .session(session) .lean() .exec() as Promise, ]); const input = reversalInput( competition, command, existingFacts, assignments, ); const preview = assertReversalPreview(input, command.impactHash); const nextRevision = command.expectedRevision + 1; const recordedAt = new Date(); const occurredAt = command.occurredAt ?? recordedAt; const rawFacts = buildReversalFacts({ preview, facts: input.facts, competitionId: idString(command.competitionId), commandId, nextRevision, actor: toPlain(command.actor) as Readonly>, reason: command.reason.trim(), occurredAt, }); const reversalFacts = rawFacts.map((rawFact) => persistenceReversalFact(rawFact, command, commandId, requestHash), ); const projection = projectCompetition({ competitionId: idString(command.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, ...reversalFacts].map(factForProjection), }); await FactModel.insertMany(reversalFacts, { session }); const updated = await CompetitionModel.findOneAndUpdate( { _id: command.competitionId, revision: command.expectedRevision }, { $inc: { revision: 1 }, $set: { projection, projectorVersion: competition.projectorVersion, phase: projection.phase, }, }, { returnDocument: 'after', runValidators: true, session }, ) .lean() .exec(); if (!updated) throw staleRevisionError(command.expectedRevision); await this.applyReversalAssignments( command.competitionId, competition.matchId, preview, assignments, commandId, recordedAt, session, ); await OutboxModel.insertMany( [ buildOutbox( command.competitionId, envelope, commandId, requestHash, nextRevision, reversalFacts, projection, updated, recordedAt, ), ], { session }, ); await session.commitTransaction(); return { competition: updated, commandId, revision: nextRevision, replayed: false, }; } catch (error) { await session.abortTransaction().catch(() => undefined); if ( attempt < COMMAND_TRANSACTION_ATTEMPTS && isRetryableCommandTransactionError(error) ) { lastRetryableError = error; continue; } throw error; } finally { await session.endSession(); } } throw lastRetryableError; } private async runCommand( command: CommandEnvelope, ): Promise { validateEnvelope(command); let lastRetryableError: unknown; for ( let attempt = 1; attempt <= COMMAND_TRANSACTION_ATTEMPTS; attempt += 1 ) { 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, }, }, { returnDocument: 'after', 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); if ( attempt < COMMAND_TRANSACTION_ATTEMPTS && isRetryableCommandTransactionError(error) ) { lastRetryableError = error; continue; } throw error; } finally { await session.endSession(); } } throw lastRetryableError; } private async replay( CompetitionModel: mongoose.Model, competitionId: PersistenceId, requestHash: string, receipt: Pick< CompetitionOutbox, 'requestHash' | 'idempotencyKey' | 'commandId' | 'revision' | 'payload' >, session: mongoose.ClientSession, ): Promise { 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 { const tournamentCode = command.payload.tournamentCode as | { tournamentCodeId: PersistenceId; riotMatchId: string } | undefined; if (!tournamentCode) return; const AssignmentModel = (await this.connectionService.getModel( 'tournamentCodeAssignment', )) as mongoose.Model; 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; 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); } } private async applyReversalAssignments( competitionId: PersistenceId, matchId: PersistenceId, preview: SeriesReversalPreview, assignments: AssignmentRecord[], commandId: string, recordedAt: Date, session: mongoose.ClientSession, ): Promise { const impactedSlotIds = new Set(preview.impact.gameSlotIds); const impacted = assignments.filter( (assignment) => impactedSlotIds.has(idString(assignment.gameSlotId)) && (assignment.state === 'reserved' || assignment.state === 'used'), ); if (impacted.length === 0) return; const gameSlotIds = impacted.map(({ gameSlotId }) => persistenceObjectId(gameSlotId), ); const codeIds = impacted.map(({ tournamentCodeId }) => persistenceObjectId(tournamentCodeId), ); const AssignmentModel = (await this.connectionService.getModel( 'tournamentCodeAssignment', )) as mongoose.Model; await AssignmentModel.updateMany( { competitionId, gameSlotId: { $in: gameSlotIds }, state: { $in: ['reserved', 'used'] }, }, reversalStatePipeline(recordedAt, commandId), { session }, ); const TournamentCodeModel = (await this.connectionService.getModel( 'tournamentCode', )) as mongoose.Model; await TournamentCodeModel.updateMany( { _id: { $in: codeIds }, state: { $in: ['reserved', 'used'] }, }, tournamentCodeReversalStatePipeline(recordedAt), { session }, ); const MatchModel = (await this.connectionService.getModel( 'match', )) as mongoose.Model; await MatchModel.updateOne( { _id: matchId }, { $pull: { tournamentCodeIds: { $in: codeIds } } }, { session }, ); } } 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' || command.type === 'reverse-series') && String(command.payload.reason).trim().length === 0) ) { throw invalidCommandError(); } } 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> { 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, ...(command.payload.startedAt === undefined ? {} : { startedAt: command.payload.startedAt }), ...(command.payload.durationSeconds === undefined ? {} : { durationSeconds: command.payload.durationSeconds }), ...(command.payload.participants === undefined ? {} : { participants: command.payload.participants }), }; } if (command.type === 'adjudicate-series') { return { ...common, type: 'series-adjudicated', seriesId: command.payload.seriesId, decision: command.payload.decision, reason: command.payload.reason, }; } throw invalidCommandError(); } function buildOutbox( competitionId: PersistenceId, command: CommandEnvelope, commandId: string, requestHash: string, revision: number, fact: | Readonly> | readonly Readonly>[], projection: unknown, updatedCompetition: unknown, recordedAt: Date, ): Readonly> { const facts: readonly Readonly>[] = Array.isArray( fact, ) ? fact : [fact]; return { eventId: `${commandId}:competition-projected`, competitionId, revision, commandId, idempotencyKey: command.idempotencyKey, requestHash, type: 'competition.projection-updated', payload: { competitionId: idString(competitionId), sourceRevision: revision, factIds: facts.map((entry) => idString(entry._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>, ): Readonly> { const plain = toPlain(fact) as Readonly>; 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>) .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> { 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), }, ); } function reversalInput( competition: Pick, command: PreviewSeriesReversalCommand, facts: readonly unknown[], assignments: readonly AssignmentRecord[], ) { return { competitionId: idString(command.competitionId), revision: competition.revision, seriesId: idString(command.seriesId), mode: command.mode, graph: toPlain(competition.seriesGraph) as never, facts: facts.map((fact) => factForProjection(fact as Readonly>), ), assignments: assignments.map((assignment) => ({ seriesId: idString(assignment.seriesId), gameSlotId: idString(assignment.gameSlotId), state: String(assignment.state), })), }; } function persistenceReversalFact( rawFact: Record, command: ReverseSeriesCommand, commandId: string, requestHash: string, ): Readonly> { const { id, ...fields } = rawFact; return { ...fields, _id: persistenceObjectId(id as PersistenceId), competitionId: command.competitionId, commandId, idempotencyKey: command.idempotencyKey, requestHash, ...(fields.gameAcceptedFactId === undefined ? {} : { gameAcceptedFactId: persistenceObjectId( fields.gameAcceptedFactId as PersistenceId, ), }), ...(fields.adjudicationFactId === undefined ? {} : { adjudicationFactId: persistenceObjectId( fields.adjudicationFactId as PersistenceId, ), }), }; } function reversalStatePipeline( recordedAt: Date, commandId?: string, ): mongoose.PipelineStage[] { return [ { $set: { state: { $cond: [{ $eq: ['$state', 'reserved'] }, 'released', 'voided'], }, releasedAt: { $cond: [{ $eq: ['$state', 'reserved'] }, recordedAt, '$$REMOVE'], }, voidedAt: { $cond: [{ $eq: ['$state', 'used'] }, recordedAt, '$$REMOVE'], }, ...(commandId ? { commandId } : {}), }, }, ]; } function tournamentCodeReversalStatePipeline( recordedAt: Date, ): mongoose.PipelineStage[] { return [ { $set: { state: { $cond: [{ $eq: ['$state', 'reserved'] }, 'released', 'voided'], }, releasedAt: { $cond: [{ $eq: ['$state', 'reserved'] }, recordedAt, '$releasedAt'], }, matchId: { $cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$matchId'], }, gameNumber: { $cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$gameNumber'], }, bracketMatchId: { $cond: [ { $eq: ['$state', 'reserved'] }, '$$REMOVE', '$bracketMatchId', ], }, reservedAt: { $cond: [{ $eq: ['$state', 'reserved'] }, '$$REMOVE', '$reservedAt'], }, }, }, ]; } function persistenceObjectId(value: PersistenceId): PersistenceId { if (value instanceof mongoose.Types.ObjectId) return value; return mongoose.isValidObjectId(value) ? new mongoose.Types.ObjectId(value) : value; } function isRetryableCommandTransactionError(error: unknown): boolean { const candidate = error as { code?: number; codeName?: string; hasErrorLabel?: (label: string) => boolean; }; return Boolean( candidate?.code === 11_000 || candidate?.code === 112 || candidate?.codeName === 'WriteConflict' || candidate?.hasErrorLabel?.('TransientTransactionError') || candidate?.hasErrorLabel?.('UnknownTransactionCommitResult'), ); } function competitionNotFound( competitionId: PersistenceId, ): CompetitionCommandError { return new CompetitionCommandError( 'COMPETITION_NOT_FOUND', 'Competition not found.', 404, { competitionId: idString(competitionId) }, ); } function invalidCommandError(): CompetitionCommandError { return new CompetitionCommandError( 'INVALID_COMPETITION_COMMAND', 'Expected revision, valid payload, and a non-empty Idempotency-Key are required.', 422, ); }