refactor

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

@@ -15,16 +15,13 @@ import type { IWalletRepository } from '@core/payments/domain/repositories/IWall
 import type { ILeagueWalletRepository } from '../../domain/repositories/ILeagueWalletRepository';
 import { SeasonSponsorship } from '../../domain/entities/SeasonSponsorship';
 import type { AsyncUseCase } from '@core/shared/application';
-import { Result } from '@core/shared/result/Result';
-import {
-  RacingDomainValidationError,
-  RacingDomainInvariantError,
-} from '../../domain/errors/RacingDomainError';
+import { Result } from '@core/shared/application/Result';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 import type { AcceptSponsorshipRequestDTO } from '../dto/AcceptSponsorshipRequestDTO';
 import type { AcceptSponsorshipRequestResultDTO } from '../dto/AcceptSponsorshipRequestResultDTO';
 
 export class AcceptSponsorshipRequestUseCase
-  implements AsyncUseCase<AcceptSponsorshipRequestDTO, Result<AcceptSponsorshipRequestResultDTO, RacingDomainValidationError | RacingDomainInvariantError>> {
+  implements AsyncUseCase<AcceptSponsorshipRequestDTO, AcceptSponsorshipRequestResultDTO, string> {
   constructor(
     private readonly sponsorshipRequestRepo: ISponsorshipRequestRepository,
     private readonly seasonSponsorshipRepo: ISeasonSponsorshipRepository,
@@ -36,19 +33,19 @@ export class AcceptSponsorshipRequestUseCase
     private readonly logger: Logger,
   ) {}
 
-  async execute(dto: AcceptSponsorshipRequestDTO): Promise<Result<AcceptSponsorshipRequestResultDTO, RacingDomainValidationError | RacingDomainInvariantError>> {
+  async execute(dto: AcceptSponsorshipRequestDTO): Promise<Result<AcceptSponsorshipRequestResultDTO, ApplicationErrorCode<string>>> {
     this.logger.debug(`Attempting to accept sponsorship request: ${dto.requestId}`, { requestId: dto.requestId, respondedBy: dto.respondedBy });
 
     // Find the request
     const request = await this.sponsorshipRequestRepo.findById(dto.requestId);
     if (!request) {
       this.logger.warn(`Sponsorship request not found: ${dto.requestId}`, { requestId: dto.requestId });
-      return Result.err(new RacingDomainValidationError('Sponsorship request not found'));
+      return Result.err({ code: 'SPONSORSHIP_REQUEST_NOT_FOUND' });
     }
 
     if (!request.isPending()) {
       this.logger.warn(`Cannot accept a ${request.status} sponsorship request: ${dto.requestId}`, { requestId: dto.requestId, status: request.status });
-      return Result.err(new RacingDomainValidationError(`Cannot accept a ${request.status} sponsorship request`));
+      return Result.err({ code: 'SPONSORSHIP_REQUEST_NOT_PENDING' });
     }
 
     this.logger.info(`Sponsorship request ${dto.requestId} found and is pending. Proceeding with acceptance.`, { requestId: dto.requestId });
@@ -66,7 +63,7 @@ export class AcceptSponsorshipRequestUseCase
       const season = await this.seasonRepository.findById(request.entityId);
       if (!season) {
         this.logger.warn(`Season not found for sponsorship request ${dto.requestId} and entityId ${request.entityId}`, { requestId: dto.requestId, entityId: request.entityId });
-        return Result.err(new RacingDomainValidationError('Season not found for sponsorship request'));
+        return Result.err({ code: 'SEASON_NOT_FOUND' });
       }
 
       const sponsorship = SeasonSponsorship.create({
@@ -104,20 +101,20 @@ export class AcceptSponsorshipRequestUseCase
       );
       if (!paymentResult.success) {
         this.logger.error(`Payment failed for sponsorship request ${request.id}: ${paymentResult.error}`, undefined, { requestId: request.id });
-        return Result.err(new RacingDomainInvariantError('Payment processing failed'));
+        return Result.err({ code: 'PAYMENT_PROCESSING_FAILED' });
       }
 
       // Update wallets
       const sponsorWallet = await this.walletRepository.findById(request.sponsorId);
       if (!sponsorWallet) {
         this.logger.error(`Sponsor wallet not found for ${request.sponsorId}`, undefined, { sponsorId: request.sponsorId });
-        return Result.err(new RacingDomainInvariantError('Sponsor wallet not found'));
+        return Result.err({ code: 'SPONSOR_WALLET_NOT_FOUND' });
       }
 
       const leagueWallet = await this.leagueWalletRepository.findById(season.leagueId);
       if (!leagueWallet) {
         this.logger.error(`League wallet not found for ${season.leagueId}`, undefined, { leagueId: season.leagueId });
-        return Result.err(new RacingDomainInvariantError('League wallet not found'));
+        return Result.err({ code: 'LEAGUE_WALLET_NOT_FOUND' });
       }
 
       const netAmount = acceptedRequest.getNetAmount();