refactor core presenters

apps/api/src/domain/driver/DriverService.ts

@@ -13,15 +13,14 @@ import { GetDriversLeaderboardUseCase } from '@core/racing/application/use-cases
 import { GetTotalDriversUseCase } from '@core/racing/application/use-cases/GetTotalDriversUseCase';
 import { CompleteDriverOnboardingUseCase } from '@core/racing/application/use-cases/CompleteDriverOnboardingUseCase';
 import { IsDriverRegisteredForRaceUseCase } from '@core/racing/application/use-cases/IsDriverRegisteredForRaceUseCase';
+import { GetProfileOverviewUseCase } from '@core/racing/application/use-cases/GetProfileOverviewUseCase';
 
 // Presenters
-import { DriversLeaderboardPresenter } from './presenters/DriversLeaderboardPresenter';
 import { DriverStatsPresenter } from './presenters/DriverStatsPresenter';
-import { CompleteOnboardingPresenter } from './presenters/CompleteOnboardingPresenter';
-import { DriverRegistrationStatusPresenter } from './presenters/DriverRegistrationStatusPresenter';
 
 // Tokens
-import { GET_DRIVERS_LEADERBOARD_USE_CASE_TOKEN, GET_TOTAL_DRIVERS_USE_CASE_TOKEN, COMPLETE_DRIVER_ONBOARDING_USE_CASE_TOKEN, IS_DRIVER_REGISTERED_FOR_RACE_USE_CASE_TOKEN, UPDATE_DRIVER_PROFILE_USE_CASE_TOKEN, LOGGER_TOKEN, DRIVER_REPOSITORY_TOKEN } from './DriverProviders';
+import { GET_DRIVERS_LEADERBOARD_USE_CASE_TOKEN, GET_TOTAL_DRIVERS_USE_CASE_TOKEN, COMPLETE_DRIVER_ONBOARDING_USE_CASE_TOKEN, IS_DRIVER_REGISTERED_FOR_RACE_USE_CASE_TOKEN, UPDATE_DRIVER_PROFILE_USE_CASE_TOKEN, GET_PROFILE_OVERVIEW_USE_CASE_TOKEN, LOGGER_TOKEN, DRIVER_REPOSITORY_TOKEN } from './DriverProviders';
+import type { ProfileOverviewOutputPort } from '@core/racing/application/ports/output/ProfileOverviewOutputPort';
 import type { Logger } from '@core/shared/application';
 import { IDriverRepository } from '@core/racing/domain/repositories/IDriverRepository';
 import { UpdateDriverProfileUseCase } from '@core/racing/application/use-cases/UpdateDriverProfileUseCase';
@@ -34,6 +33,7 @@ export class DriverService {
     @Inject(COMPLETE_DRIVER_ONBOARDING_USE_CASE_TOKEN) private readonly completeDriverOnboardingUseCase: CompleteDriverOnboardingUseCase,
     @Inject(IS_DRIVER_REGISTERED_FOR_RACE_USE_CASE_TOKEN) private readonly isDriverRegisteredForRaceUseCase: IsDriverRegisteredForRaceUseCase,
     @Inject(UPDATE_DRIVER_PROFILE_USE_CASE_TOKEN) private readonly updateDriverProfileUseCase: UpdateDriverProfileUseCase,
+    @Inject(GET_PROFILE_OVERVIEW_USE_CASE_TOKEN) private readonly getProfileOverviewUseCase: GetProfileOverviewUseCase,
     @Inject(DRIVER_REPOSITORY_TOKEN) private readonly driverRepository: IDriverRepository,
     @Inject(LOGGER_TOKEN) private readonly logger: Logger,
   ) {}
@@ -41,24 +41,31 @@ export class DriverService {
   async getDriversLeaderboard(): Promise<DriversLeaderboardDTO> {
     this.logger.debug('[DriverService] Fetching drivers leaderboard.');
 
-    const presenter = new DriversLeaderboardPresenter();
-    await this.getDriversLeaderboardUseCase.execute(undefined, presenter);
-    return presenter.viewModel;
+    const result = await this.getDriversLeaderboardUseCase.execute();
+    if (result.isOk()) {
+      return result.value as DriversLeaderboardDTO;
+    } else {
+      throw new Error(`Failed to fetch drivers leaderboard: ${result.error.details.message}`);
+    }
   }
 
   async getTotalDrivers(): Promise<DriverStatsDTO> {
     this.logger.debug('[DriverService] Fetching total drivers count.');
 
+    const result = await this.getTotalDriversUseCase.execute();
+    if (result.isErr()) {
+      throw new Error(result.unwrapErr().code);
+    }
+
     const presenter = new DriverStatsPresenter();
-    await this.getTotalDriversUseCase.execute(undefined, presenter);
+    presenter.present(result.unwrap());
     return presenter.viewModel;
   }
 
   async completeOnboarding(userId: string, input: CompleteOnboardingInputDTO): Promise<CompleteOnboardingOutputDTO> {
     this.logger.debug('Completing onboarding for user:', userId);
 
-    const presenter = new CompleteOnboardingPresenter();
-    await this.completeDriverOnboardingUseCase.execute({
+    const result = await this.completeDriverOnboardingUseCase.execute({
       userId,
       firstName: input.firstName,
       lastName: input.lastName,
@@ -66,16 +73,31 @@ export class DriverService {
       country: input.country,
       timezone: input.timezone,
       bio: input.bio,
-    }, presenter);
-    return presenter.viewModel;
+    });
+
+    if (result.isOk()) {
+      return {
+        success: true,
+        driverId: result.value.driverId,
+      };
+    } else {
+      return {
+        success: false,
+        errorMessage: result.error.code,
+      };
+    }
   }
 
   async getDriverRegistrationStatus(query: GetDriverRegistrationStatusQueryDTO): Promise<DriverRegistrationStatusDTO> {
     this.logger.debug('Checking driver registration status:', query);
 
-    const presenter = new DriverRegistrationStatusPresenter();
-    await this.isDriverRegisteredForRaceUseCase.execute({ raceId: query.raceId, driverId: query.driverId }, presenter);
-    return presenter.viewModel;
+    const result = await this.isDriverRegisteredForRaceUseCase.execute({ raceId: query.raceId, driverId: query.driverId });
+    if (result.isOk()) {
+      return result.value;
+    } else {
+      // For now, throw error or handle appropriately. Since it's a query, perhaps return default or throw.
+      throw new Error(`Failed to check registration status: ${result.error.code}`);
+    }
   }
 
   async getCurrentDriver(userId: string): Promise<GetDriverOutputDTO | null> {
@@ -129,18 +151,42 @@ export class DriverService {
   async getDriverProfile(driverId: string): Promise<GetDriverProfileOutputDTO> {
     this.logger.debug(`[DriverService] Fetching driver profile for driverId: ${driverId}`);
 
-    // TODO: Implement proper driver profile fetching with all the detailed data
-    // For now, return a placeholder structure
+    const result = await this.getProfileOverviewUseCase.execute({ driverId });
+    if (result.isErr()) {
+      throw new Error(`Failed to fetch driver profile: ${result.error.code}`);
+    }
+
+    const outputPort = result.value;
+    return this.mapProfileOverviewToDTO(outputPort);
+  }
+
+  private mapProfileOverviewToDTO(outputPort: ProfileOverviewOutputPort): GetDriverProfileOutputDTO {
     return {
-      currentDriver: null,
-      stats: null,
-      finishDistribution: null,
-      teamMemberships: [],
-      socialSummary: {
-        friendsCount: 0,
-        friends: [],
-      },
-      extendedProfile: null,
+      currentDriver: outputPort.driver ? {
+        id: outputPort.driver.id,
+        name: outputPort.driver.name,
+        country: outputPort.driver.country,
+        avatarUrl: outputPort.driver.avatarUrl,
+        iracingId: outputPort.driver.iracingId,
+        joinedAt: outputPort.driver.joinedAt.toISOString(),
+        rating: outputPort.driver.rating,
+        globalRank: outputPort.driver.globalRank,
+        consistency: outputPort.driver.consistency,
+        bio: outputPort.driver.bio,
+        totalDrivers: outputPort.driver.totalDrivers,
+      } : null,
+      stats: outputPort.stats,
+      finishDistribution: outputPort.finishDistribution,
+      teamMemberships: outputPort.teamMemberships.map(membership => ({
+        teamId: membership.teamId,
+        teamName: membership.teamName,
+        teamTag: membership.teamTag,
+        role: membership.role,
+        joinedAt: membership.joinedAt.toISOString(),
+        isCurrent: membership.isCurrent,
+      })),
+      socialSummary: outputPort.socialSummary,
+      extendedProfile: outputPort.extendedProfile,
     };
   }
 }