refactor

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

@@ -8,17 +8,15 @@ import { Standing } from '../../domain/entities/Standing';
 import { RaceResultGenerator } from '../utils/RaceResultGenerator';
 import { RatingUpdateService } from '@core/identity/domain/services/RatingUpdateService';
 import type { AsyncUseCase } from '@core/shared/application';
-import type { Logger } from '@core/shared/application';
+import { Result as SharedResult } from '@core/shared/result/Result';
+import { RacingDomainValidationError } from '../../domain/errors/RacingDomainError';
+import type { CompleteRaceCommandDTO } from '../dto/CompleteRaceCommandDTO';
 
 /**
  * Enhanced CompleteRaceUseCase that includes rating updates
  */
-export interface CompleteRaceCommandDTO {
-  raceId: string;
-}
-
 export class CompleteRaceUseCaseWithRatings
-  implements AsyncUseCase<CompleteRaceCommandDTO, void> {
+  implements AsyncUseCase<CompleteRaceCommandDTO, SharedResult<void, RacingDomainValidationError>> {
   constructor(
     private readonly raceRepository: IRaceRepository,
     private readonly raceRegistrationRepository: IRaceRegistrationRepository,
@@ -26,64 +24,47 @@ export class CompleteRaceUseCaseWithRatings
     private readonly standingRepository: IStandingRepository,
     private readonly driverRatingProvider: DriverRatingProvider,
     private readonly ratingUpdateService: RatingUpdateService,
-    private readonly logger: Logger,
   ) {}
 
-  async execute(command: CompleteRaceCommandDTO): Promise<void> {
-    const { raceId } = command;
-    this.logger.debug(`Attempting to complete race with ID: ${raceId}`);
-
+  async execute(command: CompleteRaceCommandDTO): Promise<SharedResult<void, RacingDomainValidationError>> {
     try {
+      const { raceId } = command;
+
       const race = await this.raceRepository.findById(raceId);
       if (!race) {
-        this.logger.error(`Race not found for ID: ${raceId}`);
-        throw new Error('Race not found');
+        return SharedResult.err(new RacingDomainValidationError('Race not found'));
       }
-      this.logger.debug(`Found race: ${race.id}`);
 
       // Get registered drivers for this race
       const registeredDriverIds = await this.raceRegistrationRepository.getRegisteredDrivers(raceId);
       if (registeredDriverIds.length === 0) {
-        this.logger.warn(`No registered drivers for race ID: ${raceId}. Cannot complete race.`);
-        throw new Error('Cannot complete race with no registered drivers');
+        return SharedResult.err(new RacingDomainValidationError('Cannot complete race with no registered drivers'));
       }
-      this.logger.debug(`Found ${registeredDriverIds.length} registered drivers for race ID: ${raceId}`);
 
       // Get driver ratings
-      this.logger.debug('Fetching driver ratings...');
       const driverRatings = this.driverRatingProvider.getRatings(registeredDriverIds);
-      this.logger.debug('Driver ratings fetched.');
 
       // Generate realistic race results
-      this.logger.debug('Generating race results...');
       const results = RaceResultGenerator.generateRaceResults(raceId, registeredDriverIds, driverRatings);
-      this.logger.info(`Generated ${results.length} race results for race ID: ${raceId}`);
 
       // Save results
-      this.logger.debug('Saving race results...');
       for (const result of results) {
         await this.resultRepository.create(result);
       }
-      this.logger.info('Race results saved successfully.');
 
       // Update standings
-      this.logger.debug(`Updating standings for league ID: ${race.leagueId}`);
       await this.updateStandings(race.leagueId, results);
-      this.logger.info('Standings updated successfully.');
 
       // Update driver ratings based on performance
-      this.logger.debug('Updating driver ratings...');
       await this.updateDriverRatings(results, registeredDriverIds.length);
-      this.logger.info('Driver ratings updated successfully.');
 
       // Complete the race
-      this.logger.debug(`Marking race ID: ${raceId} as complete...`);
       const completedRace = race.complete();
       await this.raceRepository.update(completedRace);
-      this.logger.info(`Race ID: ${raceId} completed successfully.`);
+
+      return SharedResult.ok(undefined);
     } catch (error) {
-      this.logger.error(`Error completing race ${raceId}`, error instanceof Error ? error : new Error(String(error)));
-      throw error;
+      return SharedResult.err(new RacingDomainValidationError(error instanceof Error ? error.message : 'Unknown error'));
     }
   }