refactor racing use cases

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

@@ -1,27 +1,69 @@
 import { Result } from '@core/shared/application/Result';
+import type { UseCaseOutputPort } from '@core/shared/application';
 import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 import type { ILeagueMembershipRepository } from '../../domain/repositories/ILeagueMembershipRepository';
-import type { UpdateLeagueMemberRoleOutputPort } from '../ports/output/UpdateLeagueMemberRoleOutputPort';
+import { LeagueMembership } from '../../domain/entities/LeagueMembership';
 
-export interface UpdateLeagueMemberRoleUseCaseParams {
+export type UpdateLeagueMemberRoleInput = {
   leagueId: string;
   targetDriverId: string;
   newRole: string;
-}
+};
+
+export type UpdateLeagueMemberRoleResult = {
+  membership: LeagueMembership;
+};
+
+export type UpdateLeagueMemberRoleErrorCode =
+  | 'MEMBERSHIP_NOT_FOUND'
+  | 'REPOSITORY_ERROR';
 
 export class UpdateLeagueMemberRoleUseCase {
-  constructor(private readonly leagueMembershipRepository: ILeagueMembershipRepository) {}
+  constructor(
+    private readonly leagueMembershipRepository: ILeagueMembershipRepository,
+    private readonly output: UseCaseOutputPort<UpdateLeagueMemberRoleResult>,
+  ) {}
 
-  async execute(params: UpdateLeagueMemberRoleUseCaseParams): Promise<Result<UpdateLeagueMemberRoleOutputPort, ApplicationErrorCode<'MEMBERSHIP_NOT_FOUND'>>> {
-    const memberships = await this.leagueMembershipRepository.getLeagueMembers(params.leagueId);
-    const membership = memberships.find(m => m.driverId === params.targetDriverId);
-    if (!membership) {
-      return Result.err({ code: 'MEMBERSHIP_NOT_FOUND' });
+  async execute(
+    input: UpdateLeagueMemberRoleInput,
+  ): Promise<
+    Result<void, ApplicationErrorCode<UpdateLeagueMemberRoleErrorCode, { message: string }>>
+  > {
+    try {
+      const memberships = await this.leagueMembershipRepository.getLeagueMembers(input.leagueId);
+      const membership = memberships.find(m => m.driverId.toString() === input.targetDriverId);
+
+      if (!membership) {
+        return Result.err({
+          code: 'MEMBERSHIP_NOT_FOUND',
+          details: { message: 'League membership not found' },
+        });
+      }
+
+      const updatedMembership = LeagueMembership.create({
+        id: membership.id,
+        leagueId: membership.leagueId.toString(),
+        driverId: membership.driverId.toString(),
+        role: input.newRole,
+        status: membership.status.toString(),
+        joinedAt: membership.joinedAt.toDate(),
+      });
+
+      await this.leagueMembershipRepository.saveMembership(updatedMembership);
+
+      this.output.present({ membership: updatedMembership });
+
+      return Result.ok(undefined);
+    } catch (error: unknown) {
+      const message =
+        error instanceof Error && typeof error.message === 'string'
+          ? error.message
+          : 'Failed to update league member role';
+
+      return Result.err({
+        code: 'REPOSITORY_ERROR',
+        details: { message },
+      });
     }
-    await this.leagueMembershipRepository.saveMembership({
-      ...membership,
-      role: params.newRole,
-    });
-    return Result.ok({ success: true });
   }
 }