refactor racing use cases

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

@@ -1,36 +1,81 @@
 import type { ILeagueMembershipRepository } from '../../domain/repositories/ILeagueMembershipRepository';
 import type { IDriverRepository } from '../../domain/repositories/IDriverRepository';
-import type { AsyncUseCase } from '@core/shared/application';
+import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
+import type { LeagueMembership } from '../../domain/entities/LeagueMembership';
+import type { Driver } from '../../domain/entities/Driver';
+import type { League } from '../../domain/entities/League';
+import type { UseCaseOutputPort } from '@core/shared/application';
 import { Result } from '@core/shared/application/Result';
 import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
-import type { GetLeagueMembershipsOutputPort } from '../ports/output/GetLeagueMembershipsOutputPort';
 
-export interface GetLeagueMembershipsUseCaseParams {
+export interface GetLeagueMembershipsInput {
   leagueId: string;
 }
 
-export class GetLeagueMembershipsUseCase implements AsyncUseCase<GetLeagueMembershipsUseCaseParams, GetLeagueMembershipsOutputPort, 'NO_ERROR'> {
+export type GetLeagueMembershipsErrorCode = 'LEAGUE_NOT_FOUND' | 'REPOSITORY_ERROR';
+
+export interface LeagueMembershipWithDriver {
+  membership: LeagueMembership;
+  driver: Driver | null;
+}
+
+export interface GetLeagueMembershipsResult {
+  league: League;
+  memberships: LeagueMembershipWithDriver[];
+}
+
+export class GetLeagueMembershipsUseCase {
   constructor(
     private readonly leagueMembershipRepository: ILeagueMembershipRepository,
     private readonly driverRepository: IDriverRepository,
+    private readonly leagueRepository: ILeagueRepository,
+    private readonly output: UseCaseOutputPort<GetLeagueMembershipsResult>,
   ) {}
 
-  async execute(params: GetLeagueMembershipsUseCaseParams): Promise<Result<GetLeagueMembershipsOutputPort, ApplicationErrorCode<'NO_ERROR'>>> {
-    const memberships = await this.leagueMembershipRepository.getLeagueMembers(params.leagueId);
-    const drivers: { id: string; name: string }[] = [];
+  async execute(
+    input: GetLeagueMembershipsInput,
+  ): Promise<Result<void, ApplicationErrorCode<GetLeagueMembershipsErrorCode, { message: string }>>> {
+    try {
+      const league = await this.leagueRepository.findById(input.leagueId);
 
-    // Get driver details for each membership
-    for (const membership of memberships) {
-      const driver = await this.driverRepository.findById(membership.driverId);
-      if (driver) {
-        drivers.push({ id: driver.id, name: driver.name });
+      if (!league) {
+        return Result.err({
+          code: 'LEAGUE_NOT_FOUND',
+          details: { message: 'League not found' },
+        });
       }
-    }
 
-    const dto: GetLeagueMembershipsOutputPort = {
-      memberships,
-      drivers,
-    };
-    return Result.ok(dto);
+      const memberships = await this.leagueMembershipRepository.getLeagueMembers(input.leagueId);
+      const driverIds = [...new Set(memberships.map(membership => membership.driverId.toString()))];
+
+      const drivers = await Promise.all(driverIds.map(id => this.driverRepository.findById(id)));
+      const driverMap = new Map<string, Driver>(
+        drivers.filter((driver): driver is Driver => driver !== null).map(driver => [driver.id, driver]),
+      );
+
+      const membershipsWithDrivers: LeagueMembershipWithDriver[] = memberships.map(membership => ({
+        membership,
+        driver: driverMap.get(membership.driverId.toString()) ?? null,
+      }));
+
+      const result: GetLeagueMembershipsResult = {
+        league,
+        memberships: membershipsWithDrivers,
+      };
+
+      this.output.present(result);
+
+      return Result.ok(undefined);
+    } catch (error: unknown) {
+      const message =
+        error && typeof error === 'object' && 'message' in error && typeof (error as any).message === 'string'
+          ? (error as any).message
+          : 'Failed to load league memberships';
+
+      return Result.err({
+        code: 'REPOSITORY_ERROR',
+        details: { message },
+      });
+    }
   }
 }