refactor racing use cases

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

@@ -1,44 +1,101 @@
-import type { AsyncUseCase, Logger } from '@core/shared/application';
-import { Result as SharedResult } from '@core/shared/application/Result';
+import type { Logger, UseCaseOutputPort } from '@core/shared/application';
+import { Result } from '@core/shared/application/Result';
 import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
+import type { Team } from '../../domain/entities/Team';
 import type { ITeamMembershipRepository } from '../../domain/repositories/ITeamMembershipRepository';
-import type { LeaveTeamInputPort } from '../ports/input/LeaveTeamInputPort';
+import type { ITeamRepository } from '../../domain/repositories/ITeamRepository';
+import type { TeamMembership } from '../../domain/types/TeamMembership';
 
-type LeaveTeamErrorCode = 'NOT_MEMBER' | 'OWNER_CANNOT_LEAVE' | 'REPOSITORY_ERROR';
+export type LeaveTeamErrorCode =
+  | 'TEAM_NOT_FOUND'
+  | 'NOT_MEMBER'
+  | 'OWNER_CANNOT_LEAVE'
+  | 'REPOSITORY_ERROR';
 
-type LeaveTeamApplicationError = ApplicationErrorCode<LeaveTeamErrorCode, { message: string }>;
+export type LeaveTeamInput = {
+  teamId: string;
+  driverId: string;
+};
 
-export class LeaveTeamUseCase implements AsyncUseCase<LeaveTeamInputPort, void, LeaveTeamErrorCode> {
+export interface LeaveTeamResult {
+  team: Team;
+  previousMembership: TeamMembership;
+}
+
+export class LeaveTeamUseCase {
   constructor(
+    private readonly teamRepository: ITeamRepository,
     private readonly membershipRepository: ITeamMembershipRepository,
     private readonly logger: Logger,
+    private readonly output: UseCaseOutputPort<LeaveTeamResult>,
   ) {}
 
-  async execute(command: LeaveTeamInputPort): Promise<SharedResult<void, LeaveTeamApplicationError>> {
-    this.logger.debug('Attempting to leave team', { command });
-    const { teamId, driverId } = command;
+  async execute(
+    input: LeaveTeamInput,
+  ): Promise<
+    Result<void, ApplicationErrorCode<LeaveTeamErrorCode, { message: string }>>
+  > {
+    this.logger.debug('Attempting to leave team', { input });
+    const { teamId, driverId } = input;
 
     try {
-      const membership = await this.membershipRepository.getMembership(teamId, driverId);
+      const team = await this.teamRepository.findById(teamId);
+      if (!team) {
+        const error = new Error(`Team ${teamId} not found`);
+        this.logger.error('Team not found', error);
+        return Result.err({
+          code: 'TEAM_NOT_FOUND',
+          details: { message: `Team ${teamId} not found` },
+        });
+      }
+
+      const membership = await this.membershipRepository.getMembership(
+        teamId,
+        driverId,
+      );
       if (!membership) {
-        this.logger.warn('Driver is not a member of this team', { driverId, teamId });
-        return SharedResult.err({ code: 'NOT_MEMBER', details: { message: 'Not a member of this team' } });
+        this.logger.warn('Driver is not a member of this team', {
+          driverId,
+          teamId,
+        });
+        return Result.err({
+          code: 'NOT_MEMBER',
+          details: { message: 'Not a member of this team' },
+        });
       }
 
       if (membership.role === 'owner') {
         this.logger.warn('Team owner cannot leave', { driverId, teamId });
-        return SharedResult.err({
+        return Result.err({
           code: 'OWNER_CANNOT_LEAVE',
-          details: { message: 'Team owner cannot leave. Transfer ownership or disband team first.' }
+          details: {
+            message:
+              'Team owner cannot leave. Transfer ownership or disband team first.',
+          },
         });
       }
 
       await this.membershipRepository.removeMembership(teamId, driverId);
       this.logger.info('Driver successfully left team', { driverId, teamId });
-      return SharedResult.ok(undefined);
+
+      const result: LeaveTeamResult = {
+        team,
+        previousMembership: membership,
+      };
+      this.output.present(result);
+
+      return Result.ok(undefined);
     } catch (error) {
-      this.logger.error('Failed to leave team due to an unexpected error', error instanceof Error ? error : new Error('Unknown error'));
-      return SharedResult.err({ code: 'REPOSITORY_ERROR', details: { message: error instanceof Error ? error.message : 'Unknown error' } });
+      this.logger.error(
+        'Failed to leave team due to an unexpected error',
+        error instanceof Error ? error : new Error('Unknown error'),
+      );
+      return Result.err({
+        code: 'REPOSITORY_ERROR',
+        details: {
+          message: error instanceof Error ? error.message : 'Unknown error',
+        },
+      });
     }
   }
 }