refactor use cases

core/racing/application/use-cases/CloseRaceEventStewardingUseCase.ts

@@ -7,7 +7,6 @@ import { RaceEventStewardingClosedEvent } from '../../domain/events/RaceEventSte
 import { Result } from '@core/shared/application/Result';
 import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 import type { RaceEvent } from '../../domain/entities/RaceEvent';
-import type { UseCaseOutputPort } from '@core/shared/application/UseCaseOutputPort';
 
 export type CloseRaceEventStewardingInput = {
   raceId: string;
@@ -30,15 +29,20 @@ export type CloseRaceEventStewardingResult = {
 export class CloseRaceEventStewardingUseCase {
   constructor(
     private readonly logger: Logger,
-
     private readonly raceEventRepository: IRaceEventRepository,
     private readonly raceRegistrationRepository: IRaceRegistrationRepository,
     private readonly penaltyRepository: IPenaltyRepository,
     private readonly domainEventPublisher: DomainEventPublisher,
-    private readonly output: UseCaseOutputPort<CloseRaceEventStewardingResult>,
   ) {}
 
-  async execute(input: CloseRaceEventStewardingInput): Promise<Result<void, ApplicationErrorCode<'RACE_NOT_FOUND' | 'STEWARDING_ALREADY_CLOSED' | 'REPOSITORY_ERROR'>>> {
+  async execute(
+    input: CloseRaceEventStewardingInput,
+  ): Promise<
+    Result<
+      CloseRaceEventStewardingResult,
+      ApplicationErrorCode<'RACE_NOT_FOUND' | 'STEWARDING_ALREADY_CLOSED' | 'REPOSITORY_ERROR'>
+    >
+  > {
     void input;
     try {
       // Find all race events awaiting stewarding that have expired windows
@@ -51,18 +55,23 @@ export class CloseRaceEventStewardingUseCase {
         closedRaceEventIds.push(raceEvent.id);
       }
 
-      // When multiple race events are processed, we present the last closed event for simplicity
+      // When multiple race events are processed, we return the last closed event for simplicity
       const lastClosedEventId = closedRaceEventIds[closedRaceEventIds.length - 1];
       if (lastClosedEventId) {
         const lastClosedEvent = await this.raceEventRepository.findById(lastClosedEventId);
         if (lastClosedEvent) {
-          this.output.present({
+          const result: CloseRaceEventStewardingResult = {
             race: lastClosedEvent,
-          });
+          };
+          return Result.ok(result);
         }
       }
 
-      return Result.ok(undefined);
+      // If no events were closed, return an error
+      return Result.err({
+        code: 'RACE_NOT_FOUND',
+        details: { message: 'No race events found to close stewarding for' },
+      });
     } catch (error) {
       this.logger.error('Failed to close race event stewarding', error instanceof Error ? error : new Error(String(error)));
       return Result.err({
@@ -80,7 +89,7 @@ export class CloseRaceEventStewardingUseCase {
       const closedRaceEvent = raceEvent.closeStewarding();
       await this.raceEventRepository.update(closedRaceEvent);
 
-      // Get list of participating drivers
+      // Get list of participating driver IDs
       const driverIds = await this.getParticipatingDriverIds(raceEvent);
 
       // Check if any penalties were applied during stewarding