refactor racing use cases

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

@@ -1,43 +1,80 @@
 import type { IRaceRepository } from '../../domain/repositories/IRaceRepository';
 import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
-import type { RacesPageOutputPort } from '../ports/output/RacesPageOutputPort';
-import type { AsyncUseCase } from '@core/shared/application/AsyncUseCase';
+import type { Logger } from '@core/shared/application';
 import { Result } from '@core/shared/application/Result';
 import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
+import type { UseCaseOutputPort } from '@core/shared/application/UseCaseOutputPort';
+import type { Race } from '../../domain/entities/Race';
 
-export class GetRacesPageDataUseCase implements AsyncUseCase<void, RacesPageOutputPort, 'NO_ERROR'> {
+export type GetRacesPageDataInput = {
+  leagueId: string;
+};
+
+export type GetRacesPageRaceItem = {
+  race: Race;
+  leagueName: string;
+};
+
+export type GetRacesPageDataResult = {
+  leagueId: string;
+  races: GetRacesPageRaceItem[];
+};
+
+export type GetRacesPageDataErrorCode = 'REPOSITORY_ERROR';
+
+export class GetRacesPageDataUseCase {
   constructor(
     private readonly raceRepository: IRaceRepository,
     private readonly leagueRepository: ILeagueRepository,
+    private readonly logger: Logger,
+    private readonly output: UseCaseOutputPort<GetRacesPageDataResult>,
   ) {}
 
-  async execute(): Promise<Result<RacesPageOutputPort, ApplicationErrorCode<'NO_ERROR'>>> {
-    const [allRaces, allLeagues] = await Promise.all([
-      this.raceRepository.findAll(),
-      this.leagueRepository.findAll(),
-    ]);
+  async execute(
+    input: GetRacesPageDataInput,
+  ): Promise<Result<void, ApplicationErrorCode<GetRacesPageDataErrorCode, { message: string }>>> {
+    this.logger.debug('GetRacesPageDataUseCase:execute', { input });
 
-    const leagueMap = new Map(allLeagues.map(l => [l.id, l.name]));
+    try {
+      const [allRaces, allLeagues] = await Promise.all([
+        this.raceRepository.findAll(),
+        this.leagueRepository.findAll(),
+      ]);
 
-    const races = allRaces
-      .sort((a, b) => a.scheduledAt.getTime() - b.scheduledAt.getTime())
-      .map(race => ({
-        id: race.id,
-        track: race.track,
-        car: race.car,
-        scheduledAt: race.scheduledAt,
-        status: race.status,
-        leagueId: race.leagueId,
-        strengthOfField: race.strengthOfField,
+      const leagueMap = new Map(allLeagues.map(league => [league.id, league.name]));
+
+      const filteredRaces = allRaces
+        .filter(race => race.leagueId === input.leagueId)
+        .sort((a, b) => a.scheduledAt.getTime() - b.scheduledAt.getTime());
+
+      const races: GetRacesPageRaceItem[] = filteredRaces.map(race => ({
+        race,
+        leagueName: leagueMap.get(race.leagueId) ?? 'Unknown League',
       }));
 
-    const outputPort: RacesPageOutputPort = {
-      page: 1,
-      pageSize: races.length,
-      totalCount: races.length,
-      races,
-    };
+      const result: GetRacesPageDataResult = {
+        leagueId: input.leagueId,
+        races,
+      };
 
-    return Result.ok(outputPort);
+      this.output.present(result);
+
+      return Result.ok(undefined);
+    } catch (error: unknown) {
+      const message =
+        error instanceof Error && error.message
+          ? error.message
+          : 'Failed to load races page data';
+
+      this.logger.error(
+        'GetRacesPageDataUseCase:execution error',
+        error instanceof Error ? error : new Error(message),
+      );
+
+      return Result.err({
+        code: 'REPOSITORY_ERROR',
+        details: { message },
+      });
+    }
   }
-}
+}