refactor

core/payments/application/use-cases/GetMembershipFeesUseCase.ts

@@ -5,70 +5,50 @@
  */
 
 import type { IMembershipFeeRepository, IMemberPaymentRepository } from '../../domain/repositories/IMembershipFeeRepository';
-import type {
-  IGetMembershipFeesPresenter,
-  GetMembershipFeesResultDTO,
-  GetMembershipFeesViewModel,
-} from '../presenters/IGetMembershipFeesPresenter';
+import type { MembershipFee } from '../../domain/entities/MembershipFee';
+import type { MemberPayment } from '../../domain/entities/MemberPayment';
 import type { UseCase } from '@core/shared/application/UseCase';
+import type { UseCaseOutputPort } from '@core/shared/application/UseCaseOutputPort';
+import { Result } from '@core/shared/application/Result';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
+
+export type GetMembershipFeesErrorCode = 'INVALID_INPUT';
 
 export interface GetMembershipFeesInput {
   leagueId: string;
   driverId?: string;
 }
 
+export interface GetMembershipFeesResult {
+  fee: MembershipFee | null;
+  payments: MemberPayment[];
+}
+
 export class GetMembershipFeesUseCase
-  implements UseCase<GetMembershipFeesInput, GetMembershipFeesResultDTO, GetMembershipFeesViewModel, IGetMembershipFeesPresenter>
+  implements UseCase<GetMembershipFeesInput, void, GetMembershipFeesErrorCode>
 {
   constructor(
     private readonly membershipFeeRepository: IMembershipFeeRepository,
     private readonly memberPaymentRepository: IMemberPaymentRepository,
+    private readonly output: UseCaseOutputPort<GetMembershipFeesResult>,
   ) {}
 
-  async execute(
-    input: GetMembershipFeesInput,
-    presenter: IGetMembershipFeesPresenter,
-  ): Promise<void> {
-    presenter.reset();
-
+  async execute(input: GetMembershipFeesInput): Promise<Result<void, ApplicationErrorCode<GetMembershipFeesErrorCode>>> {
     const { leagueId, driverId } = input;
 
     if (!leagueId) {
-      throw new Error('leagueId is required');
+      return Result.err({ code: 'INVALID_INPUT' as const });
     }
 
     const fee = await this.membershipFeeRepository.findByLeagueId(leagueId);
-    
-    let payments: unknown[] = [];
+
+    let payments: MemberPayment[] = [];
     if (driverId && fee) {
-      const memberPayments = await this.memberPaymentRepository.findByLeagueIdAndDriverId(leagueId, driverId, this.membershipFeeRepository);
-      payments = memberPayments.map(p => ({
-        id: p.id,
-        feeId: p.feeId,
-        driverId: p.driverId,
-        amount: p.amount,
-        platformFee: p.platformFee,
-        netAmount: p.netAmount,
-        status: p.status,
-        dueDate: p.dueDate,
-        paidAt: p.paidAt,
-      }));
+      payments = await this.memberPaymentRepository.findByLeagueIdAndDriverId(leagueId, driverId, this.membershipFeeRepository);
     }
 
-    const dto: GetMembershipFeesResultDTO = {
-      fee: fee ? {
-        id: fee.id,
-        leagueId: fee.leagueId,
-        seasonId: fee.seasonId,
-        type: fee.type,
-        amount: fee.amount,
-        enabled: fee.enabled,
-        createdAt: fee.createdAt,
-        updatedAt: fee.updatedAt,
-      } : null,
-      payments,
-    };
+    this.output.present({ fee, payments });
 
-    presenter.present(dto);
+    return Result.ok(undefined);
   }
 }