presenter refactoring

apps/api/src/domain/team/TeamService.ts

@@ -1,14 +1,6 @@
 import { Injectable, Inject } from '@nestjs/common';
-import { GetAllTeamsOutputDTO } from './dtos/GetAllTeamsOutputDTO';
-import { GetTeamDetailsOutputDTO } from './dtos/GetTeamDetailsOutputDTO';
-import { GetTeamMembersOutputDTO } from './dtos/GetTeamMembersOutputDTO';
-import { GetTeamJoinRequestsOutputDTO } from './dtos/GetTeamJoinRequestsOutputDTO';
 import { CreateTeamInputDTO } from './dtos/CreateTeamInputDTO';
-import { CreateTeamOutputDTO } from './dtos/CreateTeamOutputDTO';
 import { UpdateTeamInputDTO } from './dtos/UpdateTeamInputDTO';
-import { UpdateTeamOutputDTO } from './dtos/UpdateTeamOutputDTO';
-import { GetDriverTeamOutputDTO } from './dtos/GetDriverTeamOutputDTO';
-import { GetTeamMembershipOutputDTO } from './dtos/GetTeamMembershipOutputDTO';
 
 // Core imports
 import type { Logger } from '@core/shared/application/Logger';
@@ -29,6 +21,9 @@ import { TeamDetailsPresenter } from './presenters/TeamDetailsPresenter';
 import { TeamMembersPresenter } from './presenters/TeamMembersPresenter';
 import { TeamJoinRequestsPresenter } from './presenters/TeamJoinRequestsPresenter';
 import { DriverTeamPresenter } from './presenters/DriverTeamPresenter';
+import { TeamMembershipPresenter } from './presenters/TeamMembershipPresenter';
+import { CreateTeamPresenter } from './presenters/CreateTeamPresenter';
+import { UpdateTeamPresenter } from './presenters/UpdateTeamPresenter';
 
 // Tokens
 import { LOGGER_TOKEN } from './TeamProviders';
@@ -47,125 +42,150 @@ export class TeamService {
     @Inject(LOGGER_TOKEN) private readonly logger: Logger,
   ) {}
 
-  async getAll(): Promise<GetAllTeamsOutputDTO> {
+  async getAll(): Promise<AllTeamsPresenter> {
     this.logger.debug('[TeamService] Fetching all teams.');
 
     const presenter = new AllTeamsPresenter();
     const result = await this.getAllTeamsUseCase.execute();
     if (result.isErr()) {
       this.logger.error('Error fetching all teams', result.error);
-      return { teams: [], totalCount: 0 };
+      await presenter.present({ teams: [], totalCount: 0 });
+      return presenter;
     }
+
     await presenter.present(result.value);
-    return presenter.getViewModel()!;
+    return presenter;
   }
 
-  async getDetails(teamId: string, userId?: string): Promise<GetTeamDetailsOutputDTO | null> {
+  async getDetails(teamId: string, userId?: string): Promise<TeamDetailsPresenter> {
     this.logger.debug(`[TeamService] Fetching team details for teamId: ${teamId}, userId: ${userId}`);
 
     const presenter = new TeamDetailsPresenter();
     const result = await this.getTeamDetailsUseCase.execute({ teamId, driverId: userId || '' });
     if (result.isErr()) {
       this.logger.error(`Error fetching team details for teamId: ${teamId}`, result.error);
-      return null;
+      return presenter;
     }
+
     await presenter.present(result.value);
-    return presenter.getViewModel();
+    return presenter;
   }
 
-  async getMembers(teamId: string): Promise<GetTeamMembersOutputDTO> {
+  async getMembers(teamId: string): Promise<TeamMembersPresenter> {
     this.logger.debug(`[TeamService] Fetching team members for teamId: ${teamId}`);
 
     const presenter = new TeamMembersPresenter();
     const result = await this.getTeamMembersUseCase.execute({ teamId });
     if (result.isErr()) {
       this.logger.error(`Error fetching team members for teamId: ${teamId}`, result.error);
-      return {
+      await presenter.present({
         members: [],
         totalCount: 0,
         ownerCount: 0,
         managerCount: 0,
         memberCount: 0,
-      };
+      } as unknown as any);
+      return presenter;
     }
+
     await presenter.present(result.value);
-    return presenter.getViewModel()!;
+    return presenter;
   }
 
-  async getJoinRequests(teamId: string): Promise<GetTeamJoinRequestsOutputDTO> {
+  async getJoinRequests(teamId: string): Promise<TeamJoinRequestsPresenter> {
     this.logger.debug(`[TeamService] Fetching team join requests for teamId: ${teamId}`);
 
     const presenter = new TeamJoinRequestsPresenter();
     const result = await this.getTeamJoinRequestsUseCase.execute({ teamId });
     if (result.isErr()) {
       this.logger.error(`Error fetching team join requests for teamId: ${teamId}`, result.error);
-      return {
+      await presenter.present({
         requests: [],
         pendingCount: 0,
         totalCount: 0,
-      };
+      } as unknown as any);
+      return presenter;
     }
+
     await presenter.present(result.value);
-    return presenter.getViewModel()!;
+    return presenter;
   }
 
-  async create(input: CreateTeamInputDTO, userId?: string): Promise<CreateTeamOutputDTO> {
+  async create(input: CreateTeamInputDTO, userId?: string): Promise<CreateTeamPresenter> {
     this.logger.debug('[TeamService] Creating team', { input, userId });
 
+    const presenter = new CreateTeamPresenter();
+
     const command = {
       name: input.name,
       tag: input.tag,
-      description: input.description,
+      description: input.description ?? '',
       ownerId: userId || '',
+      leagues: [],
     };
-    const result = await this.createTeamUseCase.execute(command);
+
+    const result = await this.createTeamUseCase.execute(command as any);
     if (result.isErr()) {
       this.logger.error('Error creating team', result.error);
-      return { id: '', success: false };
+      presenter.presentError();
+      return presenter;
     }
-    return { id: result.value.id, success: true };
+
+    presenter.presentSuccess(result.value);
+    return presenter;
   }
 
-  async update(teamId: string, input: UpdateTeamInputDTO, userId?: string): Promise<UpdateTeamOutputDTO> {
+  async update(teamId: string, input: UpdateTeamInputDTO, userId?: string): Promise<UpdateTeamPresenter> {
     this.logger.debug(`[TeamService] Updating team ${teamId}`, { input, userId });
 
+    const presenter = new UpdateTeamPresenter();
+
     const command = {
       teamId,
-      name: input.name,
-      tag: input.tag,
-      description: input.description,
-      performerId: userId || '',
+      updates: {
+        name: input.name,
+        tag: input.tag,
+        description: input.description,
+      },
+      updatedBy: userId || '',
     };
-    const result = await this.updateTeamUseCase.execute(command);
+
+    const result = await this.updateTeamUseCase.execute(command as any);
     if (result.isErr()) {
       this.logger.error(`Error updating team ${teamId}`, result.error);
-      return { success: false };
+      presenter.presentError();
+      return presenter;
     }
-    return { success: true };
+
+    presenter.presentSuccess();
+    return presenter;
   }
 
-  async getDriverTeam(driverId: string): Promise<GetDriverTeamOutputDTO | null> {
+  async getDriverTeam(driverId: string): Promise<DriverTeamPresenter> {
     this.logger.debug(`[TeamService] Fetching driver team for driverId: ${driverId}`);
 
+    const presenter = new DriverTeamPresenter();
     const result = await this.getDriverTeamUseCase.execute({ driverId });
     if (result.isErr()) {
       this.logger.error(`Error fetching driver team for driverId: ${driverId}`, result.error);
-      return null;
+      return presenter;
     }
 
-    const presenter = new DriverTeamPresenter();
     await presenter.present(result.value);
-    return presenter.getViewModel();
+    return presenter;
   }
 
-  async getMembership(teamId: string, driverId: string): Promise<GetTeamMembershipOutputDTO | null> {
+  async getMembership(teamId: string, driverId: string): Promise<TeamMembershipPresenter> {
     this.logger.debug(`[TeamService] Fetching team membership for teamId: ${teamId}, driverId: ${driverId}`);
 
+    const presenter = new TeamMembershipPresenter();
     const result = await this.getTeamMembershipUseCase.execute({ teamId, driverId });
     if (result.isErr()) {
       this.logger.error(`Error fetching team membership for teamId: ${teamId}, driverId: ${driverId}`, result.error);
-      return null;
+      return presenter;
     }
-    return result.value;
+
+    presenter.present(result.value as any);
+    return presenter;
   }
 }