module cleanup

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

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, Inject } from '@nestjs/common';
 import { GetAllTeamsOutputDTO } from './dtos/GetAllTeamsOutputDTO';
 import { GetTeamDetailsOutputDTO } from './dtos/GetTeamDetailsOutputDTO';
 import { GetTeamMembersOutputDTO } from './dtos/GetTeamMembersOutputDTO';
@@ -10,63 +10,162 @@ 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';
+
+// Use cases
+import { GetAllTeamsUseCase } from '@core/racing/application/use-cases/GetAllTeamsUseCase';
+import { GetTeamDetailsUseCase } from '@core/racing/application/use-cases/GetTeamDetailsUseCase';
+import { GetTeamMembersUseCase } from '@core/racing/application/use-cases/GetTeamMembersUseCase';
+import { GetTeamJoinRequestsUseCase } from '@core/racing/application/use-cases/GetTeamJoinRequestsUseCase';
+import { CreateTeamUseCase } from '@core/racing/application/use-cases/CreateTeamUseCase';
+import { UpdateTeamUseCase } from '@core/racing/application/use-cases/UpdateTeamUseCase';
+import { GetDriverTeamUseCase } from '@core/racing/application/use-cases/GetDriverTeamUseCase';
+import { GetTeamMembershipUseCase } from '@core/racing/application/use-cases/GetTeamMembershipUseCase';
+
+// API Presenters
+import { AllTeamsPresenter } from './presenters/AllTeamsPresenter';
+import { TeamDetailsPresenter } from './presenters/TeamDetailsPresenter';
+import { TeamMembersPresenter } from './presenters/TeamMembersPresenter';
+import { TeamJoinRequestsPresenter } from './presenters/TeamJoinRequestsPresenter';
+import { DriverTeamPresenter } from './presenters/DriverTeamPresenter';
+
+// Tokens
+import { LOGGER_TOKEN } from './TeamProviders';
+
 @Injectable()
 export class TeamService {
+  constructor(
+    private readonly getAllTeamsUseCase: GetAllTeamsUseCase,
+    private readonly getTeamDetailsUseCase: GetTeamDetailsUseCase,
+    private readonly getTeamMembersUseCase: GetTeamMembersUseCase,
+    private readonly getTeamJoinRequestsUseCase: GetTeamJoinRequestsUseCase,
+    private readonly createTeamUseCase: CreateTeamUseCase,
+    private readonly updateTeamUseCase: UpdateTeamUseCase,
+    private readonly getDriverTeamUseCase: GetDriverTeamUseCase,
+    private readonly getTeamMembershipUseCase: GetTeamMembershipUseCase,
+    @Inject(LOGGER_TOKEN) private readonly logger: Logger,
+  ) {}
+
   async getAll(): Promise<GetAllTeamsOutputDTO> {
-    // TODO: Implement getAll teams logic
-    return {
-      teams: [],
-      totalCount: 0,
-    };
+    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(result.value);
+    return presenter.getViewModel()!;
   }
 
   async getDetails(teamId: string, userId?: string): Promise<GetTeamDetailsOutputDTO | null> {
-    // TODO: Implement get team details logic
-    return null;
+    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;
+    }
+    await presenter.present(result.value);
+    return presenter.getViewModel();
   }
 
   async getMembers(teamId: string): Promise<GetTeamMembersOutputDTO> {
-    // TODO: Implement get team members logic
-    return {
-      members: [],
-      totalCount: 0,
-      ownerCount: 0,
-      managerCount: 0,
-      memberCount: 0,
-    };
+    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 {
+        members: [],
+        totalCount: 0,
+        ownerCount: 0,
+        managerCount: 0,
+        memberCount: 0,
+      };
+    }
+    await presenter.present(result.value);
+    return presenter.getViewModel()!;
   }
 
   async getJoinRequests(teamId: string): Promise<GetTeamJoinRequestsOutputDTO> {
-    // TODO: Implement get team join requests logic
-    return {
-      requests: [],
-      pendingCount: 0,
-      totalCount: 0,
-    };
+    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 {
+        requests: [],
+        pendingCount: 0,
+        totalCount: 0,
+      };
+    }
+    await presenter.present(result.value);
+    return presenter.getViewModel()!;
   }
 
   async create(input: CreateTeamInputDTO, userId?: string): Promise<CreateTeamOutputDTO> {
-    // TODO: Implement create team logic
-    return {
-      id: 'placeholder-id',
-      success: true,
+    this.logger.debug('[TeamService] Creating team', { input, userId });
+
+    const command = {
+      name: input.name,
+      tag: input.tag,
+      description: input.description,
+      ownerId: userId || '',
     };
+    const result = await this.createTeamUseCase.execute(command);
+    if (result.isErr()) {
+      this.logger.error('Error creating team', result.error);
+      return { id: '', success: false };
+    }
+    return { id: result.value.id, success: true };
   }
 
   async update(teamId: string, input: UpdateTeamInputDTO, userId?: string): Promise<UpdateTeamOutputDTO> {
-    // TODO: Implement update team logic
-    return {
-      success: true,
+    this.logger.debug(`[TeamService] Updating team ${teamId}`, { input, userId });
+
+    const command = {
+      teamId,
+      name: input.name,
+      tag: input.tag,
+      description: input.description,
+      performerId: userId || '',
     };
+    const result = await this.updateTeamUseCase.execute(command);
+    if (result.isErr()) {
+      this.logger.error(`Error updating team ${teamId}`, result.error);
+      return { success: false };
+    }
+    return { success: true };
   }
 
   async getDriverTeam(driverId: string): Promise<GetDriverTeamOutputDTO | null> {
-    // TODO: Implement get driver team logic
-    return null;
+    this.logger.debug(`[TeamService] Fetching driver team for driverId: ${driverId}`);
+
+    const result = await this.getDriverTeamUseCase.execute({ driverId });
+    if (result.isErr()) {
+      this.logger.error(`Error fetching driver team for driverId: ${driverId}`, result.error);
+      return null;
+    }
+
+    const presenter = new DriverTeamPresenter();
+    await presenter.present(result.value);
+    return presenter.getViewModel();
   }
 
   async getMembership(teamId: string, driverId: string): Promise<GetTeamMembershipOutputDTO | null> {
-    // TODO: Implement get team membership logic
-    return null;
+    this.logger.debug(`[TeamService] Fetching team membership for teamId: ${teamId}, driverId: ${driverId}`);
+
+    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 result.value;
   }
 }