refactor racing use cases

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

@@ -7,86 +7,103 @@
 import type { ISponsorshipRequestRepository } from '../../domain/repositories/ISponsorshipRequestRepository';
 import type { ISponsorRepository } from '../../domain/repositories/ISponsorRepository';
 import type { SponsorableEntityType } from '../../domain/entities/SponsorshipRequest';
-import type { SponsorshipTier } from '../../domain/entities/SeasonSponsorship';
-import type { PendingSponsorshipRequestsOutputPort } from '../ports/output/PendingSponsorshipRequestsOutputPort';
-import { Result } from '@core/shared/application/Result';
 import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
+import { Result } from '@core/shared/application/Result';
+import type { UseCaseOutputPort } from '@core/shared/application/UseCaseOutputPort';
+import type { SponsorshipRequest } from '../../domain/entities/SponsorshipRequest';
+import type { Sponsor } from '../../domain/entities/Sponsor';
+import { Money } from '../../domain/value-objects/Money';
 
-export interface GetPendingSponsorshipRequestsDTO {
+export interface GetPendingSponsorshipRequestsInput {
   entityType: SponsorableEntityType;
   entityId: string;
 }
 
-export interface PendingSponsorshipRequestDTO {
-  id: string;
-  sponsorId: string;
-  sponsorName: string;
-  sponsorLogo?: string;
-  tier: SponsorshipTier;
-  offeredAmount: number;
-  currency: string;
-  formattedAmount: string;
-  message?: string;
-  createdAt: Date;
-  platformFee: number;
-  netAmount: number;
+export interface PendingSponsorshipRequestFinancials {
+  offeredAmount: Money;
+  platformFee: Money;
+  netAmount: Money;
 }
 
-export interface GetPendingSponsorshipRequestsResultDTO {
+export interface PendingSponsorshipRequestSummary {
+  request: SponsorshipRequest;
+  sponsor: Sponsor | null;
+  financials: PendingSponsorshipRequestFinancials;
+}
+
+export interface GetPendingSponsorshipRequestsResult {
   entityType: SponsorableEntityType;
   entityId: string;
-  requests: PendingSponsorshipRequestDTO[];
+  requests: PendingSponsorshipRequestSummary[];
   totalCount: number;
 }
 
+export type GetPendingSponsorshipRequestsErrorCode = 'REPOSITORY_ERROR';
+
 export class GetPendingSponsorshipRequestsUseCase {
   constructor(
     private readonly sponsorshipRequestRepo: ISponsorshipRequestRepository,
     private readonly sponsorRepo: ISponsorRepository,
+    private readonly output: UseCaseOutputPort<GetPendingSponsorshipRequestsResult>,
   ) {}
 
   async execute(
-    dto: GetPendingSponsorshipRequestsDTO,
-  ): Promise<Result<PendingSponsorshipRequestsOutputPort, ApplicationErrorCode<'REPOSITORY_ERROR'>>> {
+    input: GetPendingSponsorshipRequestsInput,
+  ): Promise<
+    Result<void, ApplicationErrorCode<GetPendingSponsorshipRequestsErrorCode, { message: string }>>
+  > {
     try {
       const requests = await this.sponsorshipRequestRepo.findPendingByEntity(
-        dto.entityType,
-        dto.entityId
+        input.entityType,
+        input.entityId,
       );
 
-      const requestDTOs: PendingSponsorshipRequestDTO[] = [];
+      const summaries: PendingSponsorshipRequestSummary[] = [];
 
       for (const request of requests) {
         const sponsor = await this.sponsorRepo.findById(request.sponsorId);
 
-        requestDTOs.push({
-          id: request.id,
-          sponsorId: request.sponsorId,
-          sponsorName: sponsor?.name ?? 'Unknown Sponsor',
-          ...(sponsor?.logoUrl !== undefined ? { sponsorLogo: sponsor.logoUrl } : {}),
-          tier: request.tier,
-          offeredAmount: request.offeredAmount.amount,
-          currency: request.offeredAmount.currency,
-          formattedAmount: request.offeredAmount.format(),
-          ...(request.message !== undefined ? { message: request.message } : {}),
-          createdAt: request.createdAt,
-          platformFee: request.getPlatformFee().amount,
-          netAmount: request.getNetAmount().amount,
+        const offeredAmount = Money.create(
+          request.offeredAmount.amount,
+          request.offeredAmount.currency,
+        );
+        const platformFee = request.getPlatformFee();
+        const netAmount = request.getNetAmount();
+
+        summaries.push({
+          request,
+          sponsor: sponsor ?? null,
+          financials: {
+            offeredAmount,
+            platformFee,
+            netAmount,
+          },
         });
       }
 
       // Sort by creation date (newest first)
-      requestDTOs.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+      summaries.sort((a, b) => b.request.createdAt.getTime() - a.request.createdAt.getTime());
 
-      const outputPort: PendingSponsorshipRequestsOutputPort = {
-        entityType: dto.entityType,
-        entityId: dto.entityId,
-        requests: requestDTOs,
-        totalCount: requestDTOs.length,
+      const result: GetPendingSponsorshipRequestsResult = {
+        entityType: input.entityType,
+        entityId: input.entityId,
+        requests: summaries,
+        totalCount: summaries.length,
       };
-      return Result.ok(outputPort);
-    } catch {
-      return Result.err({ code: 'REPOSITORY_ERROR', message: 'Failed to fetch pending sponsorship requests' });
+
+      this.output.present(result);
+
+      return Result.ok(undefined);
+    } catch (error) {
+      return Result.err({
+        code: 'REPOSITORY_ERROR',
+        details: {
+          message:
+            error instanceof Error
+              ? error.message
+              : 'Failed to fetch pending sponsorship requests',
+        },
+      });
     }
   }
-}
+}