refactor racing use cases

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

@@ -1,67 +1,82 @@
 import type { ITeamMembershipRepository } from '../../domain/repositories/ITeamMembershipRepository';
 import type { IDriverRepository } from '../../domain/repositories/IDriverRepository';
-import type { GetDriverAvatarInputPort } from '../ports/input/GetDriverAvatarInputPort';
-import type { GetDriverAvatarOutputPort } from '../ports/output/GetDriverAvatarOutputPort';
-import type { TeamJoinRequestsOutputPort } from '../ports/output/TeamJoinRequestsOutputPort';
+import type { ITeamRepository } from '../../domain/repositories/ITeamRepository';
+import type { TeamJoinRequest } from '../../domain/types/TeamMembership';
+import type { Driver } from '../../domain/entities/Driver';
+import type { Team } from '../../domain/entities/Team';
+import type { UseCaseOutputPort } from '@core/shared/application';
 import { Result } from '@core/shared/application/Result';
 import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
-import type { AsyncUseCase , Logger } from '@core/shared/application';
 
-/**
- * Use Case for retrieving team join requests.
- */
-export class GetTeamJoinRequestsUseCase implements AsyncUseCase<{ teamId: string }, TeamJoinRequestsOutputPort, 'REPOSITORY_ERROR'>
-{
+export type GetTeamJoinRequestsInput = {
+  teamId: string;
+};
+
+export type GetTeamJoinRequestsErrorCode = 'TEAM_NOT_FOUND' | 'REPOSITORY_ERROR';
+
+export type TeamJoinRequestWithDriver = TeamJoinRequest & {
+  driver: Driver;
+};
+
+export type GetTeamJoinRequestsResult = {
+  team: Team;
+  joinRequests: TeamJoinRequestWithDriver[];
+};
+
+export class GetTeamJoinRequestsUseCase {
   constructor(
     private readonly membershipRepository: ITeamMembershipRepository,
     private readonly driverRepository: IDriverRepository,
-    private readonly getDriverAvatar: (input: GetDriverAvatarInputPort) => Promise<GetDriverAvatarOutputPort>,
-    private readonly logger: Logger,
+    private readonly teamRepository: ITeamRepository,
+    private readonly output: UseCaseOutputPort<GetTeamJoinRequestsResult>,
   ) {}
 
-  async execute(input: { teamId: string }): Promise<Result<TeamJoinRequestsOutputPort, ApplicationErrorCode<'REPOSITORY_ERROR'>>> {
-    this.logger.debug('Executing GetTeamJoinRequestsUseCase', { teamId: input.teamId });
-
+  async execute(
+    input: GetTeamJoinRequestsInput,
+  ): Promise<Result<void, ApplicationErrorCode<GetTeamJoinRequestsErrorCode, { message: string }>>> {
     try {
-      const requests = await this.membershipRepository.getJoinRequests(input.teamId);
-      this.logger.info('Successfully retrieved team join requests', { teamId: input.teamId, count: requests.length });
+      const team = await this.teamRepository.findById(input.teamId);
 
-      const driverNames: Record<string, string> = {};
-      const avatarUrls: Record<string, string> = {};
-
-      for (const request of requests) {
-        const driver = await this.driverRepository.findById(request.driverId);
-        if (driver) {
-          driverNames[request.driverId] = driver.name.value;
-        } else {
-          this.logger.warn(`Driver not found for ID: ${request.driverId} during join request processing.`);
-        }
-        
-        const avatarResult = await this.getDriverAvatar({ driverId: request.driverId });
-        avatarUrls[request.driverId] = avatarResult.avatarUrl;
-        this.logger.debug('Processed driver details for join request', { driverId: request.driverId });
+      if (!team) {
+        return Result.err({
+          code: 'TEAM_NOT_FOUND',
+          details: { message: 'Team not found' },
+        });
       }
 
-      const requestsViewModel = requests.map(request => ({
-        requestId: request.id,
-        driverId: request.driverId,
-        driverName: driverNames[request.driverId] || 'Unknown',
-        teamId: request.teamId,
-        status: request.status as 'pending' | 'approved' | 'rejected',
-        requestedAt: request.requestedAt instanceof Date ? request.requestedAt : new Date(request.requestedAt),
-        avatarUrl: avatarUrls[request.driverId] || '',
-      }));
+      const joinRequests = await this.membershipRepository.getJoinRequests(input.teamId);
+      const driverIds = [...new Set(joinRequests.map(request => request.driverId))];
+      const drivers = await Promise.all(driverIds.map(id => this.driverRepository.findById(id)));
 
-      const outputPort: TeamJoinRequestsOutputPort = {
-        requests: requestsViewModel,
-        pendingCount: requests.filter(r => r.status === 'pending').length,
-        totalCount: requests.length,
+      const driverMap = new Map(
+        drivers.filter((driver): driver is Driver => driver !== null).map(driver => [driver.id, driver]),
+      );
+
+      const enrichedJoinRequests: TeamJoinRequestWithDriver[] = joinRequests
+        .filter(request => driverMap.has(request.driverId))
+        .map(request => ({
+          ...request,
+          driver: driverMap.get(request.driverId)!,
+        }));
+
+      const result: GetTeamJoinRequestsResult = {
+        team,
+        joinRequests: enrichedJoinRequests,
       };
 
-      return Result.ok(outputPort);
-    } catch (error) {
-      this.logger.error('Error retrieving team join requests', { teamId: input.teamId, err: error });
-      return Result.err({ code: 'REPOSITORY_ERROR', details: { message: 'Failed to retrieve team join requests' } });
+      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 team join requests';
+
+      return Result.err({
+        code: 'REPOSITORY_ERROR',
+        details: { message },
+      });
     }
   }
-}
+}