refactor racing use cases

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

@@ -1,24 +1,83 @@
-import type { IRaceRepository } from '../../domain/repositories/IRaceRepository';
-import type { AsyncUseCase } from '@core/shared/application';
+import type { Logger, UseCaseOutputPort } from '@core/shared/application';
 import { Result } from '@core/shared/application/Result';
 import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
-import type { GetLeagueScheduleOutputPort } from '../ports/output/GetLeagueScheduleOutputPort';
+import type { League } from '../../domain/entities/League';
+import type { Race } from '../../domain/entities/Race';
+import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
+import type { IRaceRepository } from '../../domain/repositories/IRaceRepository';
 
-export interface GetLeagueScheduleUseCaseParams {
+export type GetLeagueScheduleErrorCode =
+  | 'LEAGUE_NOT_FOUND'
+  | 'REPOSITORY_ERROR';
+
+export interface GetLeagueScheduleInput {
   leagueId: string;
 }
 
-export class GetLeagueScheduleUseCase implements AsyncUseCase<GetLeagueScheduleUseCaseParams, GetLeagueScheduleOutputPort, 'NO_ERROR'> {
-  constructor(private readonly raceRepository: IRaceRepository) {}
+export interface LeagueScheduledRace {
+  race: Race;
+}
 
-  async execute(params: GetLeagueScheduleUseCaseParams): Promise<Result<GetLeagueScheduleOutputPort, ApplicationErrorCode<'NO_ERROR'>>> {
-    const races = await this.raceRepository.findByLeagueId(params.leagueId);
-    return Result.ok({
-      races: races.map(race => ({
-        id: race.id,
-        name: `${race.track} - ${race.car}`,
-        scheduledAt: race.scheduledAt,
-      })),
-    });
+export interface GetLeagueScheduleResult {
+  league: League;
+  races: LeagueScheduledRace[];
+}
+
+export class GetLeagueScheduleUseCase {
+  constructor(
+    private readonly leagueRepository: ILeagueRepository,
+    private readonly raceRepository: IRaceRepository,
+    private readonly logger: Logger,
+    private readonly output: UseCaseOutputPort<GetLeagueScheduleResult>,
+  ) {}
+
+  async execute(
+    input: GetLeagueScheduleInput,
+  ): Promise<
+    Result<void, ApplicationErrorCode<GetLeagueScheduleErrorCode, { message: string }>>
+  > {
+    this.logger.debug('Fetching league schedule', { input });
+    const { leagueId } = input;
+
+    try {
+      const league = await this.leagueRepository.findById(leagueId);
+      if (!league) {
+        this.logger.warn('League not found when fetching schedule', { leagueId });
+        return Result.err({
+          code: 'LEAGUE_NOT_FOUND',
+          details: { message: 'League not found' },
+        });
+      }
+
+      const races = await this.raceRepository.findByLeagueId(leagueId);
+
+      const scheduledRaces: LeagueScheduledRace[] = races.map(race => ({
+        race,
+      }));
+
+      const result: GetLeagueScheduleResult = {
+        league,
+        races: scheduledRaces,
+      };
+
+      this.output.present(result);
+
+      return Result.ok(undefined);
+    } catch (error) {
+      this.logger.error(
+        'Failed to load league schedule due to an unexpected error',
+        error instanceof Error ? error : new Error('Unknown error'),
+      );
+
+      return Result.err({
+        code: 'REPOSITORY_ERROR',
+        details: {
+          message:
+            error instanceof Error
+              ? error.message
+              : 'Failed to load league schedule',
+        },
+      });
+    }
   }
 }