module cleanup

apps/api/src/domain/sponsor/SponsorController.test.ts

@@ -0,0 +1,210 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { vi } from 'vitest';
+import { SponsorController } from './SponsorController';
+import { SponsorService } from './SponsorService';
+
+describe('SponsorController', () => {
+  let controller: SponsorController;
+  let sponsorService: ReturnType<typeof vi.mocked<SponsorService>>;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [SponsorController],
+      providers: [
+        {
+          provide: SponsorService,
+          useValue: {
+            getEntitySponsorshipPricing: vi.fn(),
+            getSponsors: vi.fn(),
+            createSponsor: vi.fn(),
+            getSponsorDashboard: vi.fn(),
+            getSponsorSponsorships: vi.fn(),
+            getSponsor: vi.fn(),
+            getPendingSponsorshipRequests: vi.fn(),
+            acceptSponsorshipRequest: vi.fn(),
+            rejectSponsorshipRequest: vi.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    controller = module.get<SponsorController>(SponsorController);
+    sponsorService = vi.mocked(module.get(SponsorService));
+  });
+
+  describe('getEntitySponsorshipPricing', () => {
+    it('should return sponsorship pricing', async () => {
+      const mockResult = { entityType: 'season', entityId: 'season-1', pricing: [] };
+      sponsorService.getEntitySponsorshipPricing.mockResolvedValue(mockResult);
+
+      const result = await controller.getEntitySponsorshipPricing();
+
+      expect(result).toEqual(mockResult);
+      expect(sponsorService.getEntitySponsorshipPricing).toHaveBeenCalled();
+    });
+  });
+
+  describe('getSponsors', () => {
+    it('should return sponsors list', async () => {
+      const mockResult = { sponsors: [] };
+      sponsorService.getSponsors.mockResolvedValue(mockResult);
+
+      const result = await controller.getSponsors();
+
+      expect(result).toEqual(mockResult);
+      expect(sponsorService.getSponsors).toHaveBeenCalled();
+    });
+  });
+
+  describe('createSponsor', () => {
+    it('should create sponsor', async () => {
+      const input = { name: 'Test Sponsor', contactEmail: 'test@example.com' };
+      const mockResult = { id: 'sponsor-1', name: 'Test Sponsor' };
+      sponsorService.createSponsor.mockResolvedValue(mockResult);
+
+      const result = await controller.createSponsor(input);
+
+      expect(result).toEqual(mockResult);
+      expect(sponsorService.createSponsor).toHaveBeenCalledWith(input);
+    });
+  });
+
+  describe('getSponsorDashboard', () => {
+    it('should return sponsor dashboard', async () => {
+      const sponsorId = 'sponsor-1';
+      const mockResult = { sponsorId, metrics: {}, sponsoredLeagues: [] };
+      sponsorService.getSponsorDashboard.mockResolvedValue(mockResult);
+
+      const result = await controller.getSponsorDashboard(sponsorId);
+
+      expect(result).toEqual(mockResult);
+      expect(sponsorService.getSponsorDashboard).toHaveBeenCalledWith({ sponsorId });
+    });
+
+    it('should return null when sponsor not found', async () => {
+      const sponsorId = 'sponsor-1';
+      sponsorService.getSponsorDashboard.mockResolvedValue(null);
+
+      const result = await controller.getSponsorDashboard(sponsorId);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getSponsorSponsorships', () => {
+    it('should return sponsor sponsorships', async () => {
+      const sponsorId = 'sponsor-1';
+      const mockResult = { sponsorId, sponsorships: [] };
+      sponsorService.getSponsorSponsorships.mockResolvedValue(mockResult);
+
+      const result = await controller.getSponsorSponsorships(sponsorId);
+
+      expect(result).toEqual(mockResult);
+      expect(sponsorService.getSponsorSponsorships).toHaveBeenCalledWith({ sponsorId });
+    });
+
+    it('should return null when sponsor not found', async () => {
+      const sponsorId = 'sponsor-1';
+      sponsorService.getSponsorSponsorships.mockResolvedValue(null);
+
+      const result = await controller.getSponsorSponsorships(sponsorId);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getSponsor', () => {
+    it('should return sponsor', async () => {
+      const sponsorId = 'sponsor-1';
+      const mockResult = { id: sponsorId, name: 'Test Sponsor' };
+      sponsorService.getSponsor.mockResolvedValue(mockResult);
+
+      const result = await controller.getSponsor(sponsorId);
+
+      expect(result).toEqual(mockResult);
+      expect(sponsorService.getSponsor).toHaveBeenCalledWith(sponsorId);
+    });
+
+    it('should return null when sponsor not found', async () => {
+      const sponsorId = 'sponsor-1';
+      sponsorService.getSponsor.mockResolvedValue(null);
+
+      const result = await controller.getSponsor(sponsorId);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getPendingSponsorshipRequests', () => {
+    it('should return pending sponsorship requests', async () => {
+      const query = { entityType: 'season' as const, entityId: 'season-1' };
+      const mockResult = { entityType: 'season', entityId: 'season-1', requests: [], totalCount: 0 };
+      sponsorService.getPendingSponsorshipRequests.mockResolvedValue(mockResult);
+
+      const result = await controller.getPendingSponsorshipRequests(query);
+
+      expect(result).toEqual(mockResult);
+      expect(sponsorService.getPendingSponsorshipRequests).toHaveBeenCalledWith(query);
+    });
+  });
+
+  describe('acceptSponsorshipRequest', () => {
+    it('should accept sponsorship request', async () => {
+      const requestId = 'request-1';
+      const input = { respondedBy: 'user-1' };
+      const mockResult = {
+        requestId,
+        sponsorshipId: 'sponsorship-1',
+        status: 'accepted' as const,
+        acceptedAt: new Date(),
+        platformFee: 10,
+        netAmount: 90,
+      };
+      sponsorService.acceptSponsorshipRequest.mockResolvedValue(mockResult);
+
+      const result = await controller.acceptSponsorshipRequest(requestId, input);
+
+      expect(result).toEqual(mockResult);
+      expect(sponsorService.acceptSponsorshipRequest).toHaveBeenCalledWith(requestId, input.respondedBy);
+    });
+
+    it('should return null on error', async () => {
+      const requestId = 'request-1';
+      const input = { respondedBy: 'user-1' };
+      sponsorService.acceptSponsorshipRequest.mockResolvedValue(null);
+
+      const result = await controller.acceptSponsorshipRequest(requestId, input);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('rejectSponsorshipRequest', () => {
+    it('should reject sponsorship request', async () => {
+      const requestId = 'request-1';
+      const input = { respondedBy: 'user-1', reason: 'Not interested' };
+      const mockResult = {
+        requestId,
+        status: 'rejected' as const,
+        rejectedAt: new Date(),
+        reason: 'Not interested',
+      };
+      sponsorService.rejectSponsorshipRequest.mockResolvedValue(mockResult);
+
+      const result = await controller.rejectSponsorshipRequest(requestId, input);
+
+      expect(result).toEqual(mockResult);
+      expect(sponsorService.rejectSponsorshipRequest).toHaveBeenCalledWith(requestId, input.respondedBy, input.reason);
+    });
+
+    it('should return null on error', async () => {
+      const requestId = 'request-1';
+      const input = { respondedBy: 'user-1' };
+      sponsorService.rejectSponsorshipRequest.mockResolvedValue(null);
+
+      const result = await controller.rejectSponsorshipRequest(requestId, input);
+
+      expect(result).toBeNull();
+    });
+  });
+});

apps/api/src/domain/sponsor/SponsorController.ts

@@ -13,6 +13,8 @@ import { GetSponsorOutputDTO } from './dtos/GetSponsorOutputDTO';
 import { GetPendingSponsorshipRequestsOutputDTO } from './dtos/GetPendingSponsorshipRequestsOutputDTO';
 import { AcceptSponsorshipRequestInputDTO } from './dtos/AcceptSponsorshipRequestInputDTO';
 import { RejectSponsorshipRequestInputDTO } from './dtos/RejectSponsorshipRequestInputDTO';
+import type { AcceptSponsorshipRequestResultDTO } from '@core/racing/application/dtos/AcceptSponsorshipRequestResultDTO';
+import type { RejectSponsorshipRequestResultDTO } from '@core/racing/application/use-cases/RejectSponsorshipRequestUseCase';
 
 @ApiTags('sponsors')
 @Controller('sponsors')
@@ -69,26 +71,26 @@ export class SponsorController {
   @ApiOperation({ summary: 'Get pending sponsorship requests' })
   @ApiResponse({ status: 200, description: 'List of pending sponsorship requests', type: GetPendingSponsorshipRequestsOutputDTO })
   async getPendingSponsorshipRequests(@Query() query: { entityType: string; entityId: string }): Promise<GetPendingSponsorshipRequestsOutputDTO> {
-    return this.sponsorService.getPendingSponsorshipRequests(query);
+    return this.sponsorService.getPendingSponsorshipRequests(query as { entityType: import('@core/racing/domain/entities/SponsorshipRequest').SponsorableEntityType; entityId: string });
   }
 
   @Post('requests/:requestId/accept')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({ summary: 'Accept a sponsorship request' })
-  @ApiResponse({ status: 200, description: 'Sponsorship request accepted' })
-  @ApiResponse({ status: 400, description: 'Invalid request' })
-  @ApiResponse({ status: 404, description: 'Request not found' })
-  async acceptSponsorshipRequest(@Param('requestId') requestId: string, @Body() input: AcceptSponsorshipRequestInputDTO): Promise<any> {
-    return this.sponsorService.acceptSponsorshipRequest(requestId, input.respondedBy);
-  }
+   @HttpCode(HttpStatus.OK)
+   @ApiOperation({ summary: 'Accept a sponsorship request' })
+   @ApiResponse({ status: 200, description: 'Sponsorship request accepted' })
+   @ApiResponse({ status: 400, description: 'Invalid request' })
+   @ApiResponse({ status: 404, description: 'Request not found' })
+   async acceptSponsorshipRequest(@Param('requestId') requestId: string, @Body() input: AcceptSponsorshipRequestInputDTO): Promise<AcceptSponsorshipRequestResultDTO | null> {
+     return this.sponsorService.acceptSponsorshipRequest(requestId, input.respondedBy);
+   }
 
-  @Post('requests/:requestId/reject')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({ summary: 'Reject a sponsorship request' })
-  @ApiResponse({ status: 200, description: 'Sponsorship request rejected' })
-  @ApiResponse({ status: 400, description: 'Invalid request' })
-  @ApiResponse({ status: 404, description: 'Request not found' })
-  async rejectSponsorshipRequest(@Param('requestId') requestId: string, @Body() input: RejectSponsorshipRequestInputDTO): Promise<any> {
-    return this.sponsorService.rejectSponsorshipRequest(requestId, input.respondedBy, input.reason);
-  }
+   @Post('requests/:requestId/reject')
+   @HttpCode(HttpStatus.OK)
+   @ApiOperation({ summary: 'Reject a sponsorship request' })
+   @ApiResponse({ status: 200, description: 'Sponsorship request rejected' })
+   @ApiResponse({ status: 400, description: 'Invalid request' })
+   @ApiResponse({ status: 404, description: 'Request not found' })
+   async rejectSponsorshipRequest(@Param('requestId') requestId: string, @Body() input: RejectSponsorshipRequestInputDTO): Promise<RejectSponsorshipRequestResultDTO | null> {
+     return this.sponsorService.rejectSponsorshipRequest(requestId, input.respondedBy, input.reason);
+   }
 }

apps/api/src/domain/sponsor/SponsorProviders.ts

@@ -10,6 +10,10 @@ import { ILeagueMembershipRepository } from '@core/racing/domain/repositories/IL
 import { IRaceRepository } from '@core/racing/domain/repositories/IRaceRepository';
 import { ISponsorshipPricingRepository } from '@core/racing/domain/repositories/ISponsorshipPricingRepository';
 import { ISponsorshipRequestRepository } from '@core/racing/domain/repositories/ISponsorshipRequestRepository';
+import { INotificationService } from '@core/notifications/application/ports/INotificationService';
+import { IPaymentGateway } from '@core/racing/application/ports/IPaymentGateway';
+import { IWalletRepository } from '@core/payments/domain/repositories/IWalletRepository';
+import { ILeagueWalletRepository } from '@core/racing/domain/repositories/ILeagueWalletRepository';
 import type { Logger } from '@core/shared/application';
 
 // Import use cases
@@ -152,7 +156,7 @@ export const SponsorProviders: Provider[] = [
   },
   {
     provide: ACCEPT_SPONSORSHIP_REQUEST_USE_CASE_TOKEN,
-    useFactory: (sponsorshipRequestRepo: ISponsorshipRequestRepository, seasonSponsorshipRepo: ISeasonSponsorshipRepository, seasonRepo: ISeasonRepository, notificationService: any, paymentGateway: any, walletRepository: any, leagueWalletRepository: any, logger: Logger) =>
+    useFactory: (sponsorshipRequestRepo: ISponsorshipRequestRepository, seasonSponsorshipRepo: ISeasonSponsorshipRepository, seasonRepo: ISeasonRepository, notificationService: INotificationService, paymentGateway: IPaymentGateway, walletRepository: IWalletRepository, leagueWalletRepository: ILeagueWalletRepository, logger: Logger) =>
       new AcceptSponsorshipRequestUseCase(sponsorshipRequestRepo, seasonSponsorshipRepo, seasonRepo, notificationService, paymentGateway, walletRepository, leagueWalletRepository, logger),
     inject: [SPONSORSHIP_REQUEST_REPOSITORY_TOKEN, SEASON_SPONSORSHIP_REPOSITORY_TOKEN, SEASON_REPOSITORY_TOKEN, 'INotificationService', 'IPaymentGateway', 'IWalletRepository', 'ILeagueWalletRepository', LOGGER_TOKEN],
   },

apps/api/src/domain/sponsor/SponsorService.test.ts

@@ -0,0 +1,258 @@
+import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
+import { SponsorService } from './SponsorService';
+import type { GetSponsorshipPricingUseCase } from '@core/racing/application/use-cases/GetSponsorshipPricingUseCase';
+import type { GetSponsorsUseCase } from '@core/racing/application/use-cases/GetSponsorsUseCase';
+import type { CreateSponsorUseCase } from '@core/racing/application/use-cases/CreateSponsorUseCase';
+import type { GetSponsorDashboardUseCase } from '@core/racing/application/use-cases/GetSponsorDashboardUseCase';
+import type { GetSponsorSponsorshipsUseCase } from '@core/racing/application/use-cases/GetSponsorSponsorshipsUseCase';
+import type { GetSponsorUseCase } from '@core/racing/application/use-cases/GetSponsorUseCase';
+import type { GetPendingSponsorshipRequestsUseCase } from '@core/racing/application/use-cases/GetPendingSponsorshipRequestsUseCase';
+import type { AcceptSponsorshipRequestUseCase } from '@core/racing/application/use-cases/AcceptSponsorshipRequestUseCase';
+import type { RejectSponsorshipRequestUseCase } from '@core/racing/application/use-cases/RejectSponsorshipRequestUseCase';
+import type { Logger } from '@core/shared/application';
+import { Result } from '@core/shared/application/Result';
+
+describe('SponsorService', () => {
+  let service: SponsorService;
+  let getSponsorshipPricingUseCase: { execute: Mock };
+  let getSponsorsUseCase: { execute: Mock };
+  let createSponsorUseCase: { execute: Mock };
+  let getSponsorDashboardUseCase: { execute: Mock };
+  let getSponsorSponsorshipsUseCase: { execute: Mock };
+  let getSponsorUseCase: { execute: Mock };
+  let getPendingSponsorshipRequestsUseCase: { execute: Mock };
+  let acceptSponsorshipRequestUseCase: { execute: Mock };
+  let rejectSponsorshipRequestUseCase: { execute: Mock };
+  let logger: {
+    debug: Mock;
+    info: Mock;
+    warn: Mock;
+    error: Mock;
+  };
+
+  beforeEach(() => {
+    getSponsorshipPricingUseCase = { execute: vi.fn() };
+    getSponsorsUseCase = { execute: vi.fn() };
+    createSponsorUseCase = { execute: vi.fn() };
+    getSponsorDashboardUseCase = { execute: vi.fn() };
+    getSponsorSponsorshipsUseCase = { execute: vi.fn() };
+    getSponsorUseCase = { execute: vi.fn() };
+    getPendingSponsorshipRequestsUseCase = { execute: vi.fn() };
+    acceptSponsorshipRequestUseCase = { execute: vi.fn() };
+    rejectSponsorshipRequestUseCase = { execute: vi.fn() };
+    logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    };
+
+    service = new SponsorService(
+      getSponsorshipPricingUseCase as unknown as GetSponsorshipPricingUseCase,
+      getSponsorsUseCase as unknown as GetSponsorsUseCase,
+      createSponsorUseCase as unknown as CreateSponsorUseCase,
+      getSponsorDashboardUseCase as unknown as GetSponsorDashboardUseCase,
+      getSponsorSponsorshipsUseCase as unknown as GetSponsorSponsorshipsUseCase,
+      getSponsorUseCase as unknown as GetSponsorUseCase,
+      getPendingSponsorshipRequestsUseCase as unknown as GetPendingSponsorshipRequestsUseCase,
+      acceptSponsorshipRequestUseCase as unknown as AcceptSponsorshipRequestUseCase,
+      rejectSponsorshipRequestUseCase as unknown as RejectSponsorshipRequestUseCase,
+      logger as unknown as Logger,
+    );
+  });
+
+  describe('getEntitySponsorshipPricing', () => {
+    it('should return sponsorship pricing', async () => {
+      const mockPresenter = {
+        viewModel: { entityType: 'season', entityId: 'season-1', pricing: [] },
+      };
+      getSponsorshipPricingUseCase.execute.mockResolvedValue(undefined);
+
+      // Mock the presenter
+      const originalGetSponsorshipPricingPresenter = await import('./presenters/GetSponsorshipPricingPresenter');
+      const mockPresenterClass = vi.fn().mockImplementation(() => mockPresenter);
+      vi.doMock('./presenters/GetSponsorshipPricingPresenter', () => ({
+        GetSponsorshipPricingPresenter: mockPresenterClass,
+      }));
+
+      const result = await service.getEntitySponsorshipPricing();
+
+      expect(result).toEqual(mockPresenter.viewModel);
+      expect(getSponsorshipPricingUseCase.execute).toHaveBeenCalledWith(undefined, mockPresenter);
+    });
+  });
+
+  describe('getSponsors', () => {
+    it('should return sponsors list', async () => {
+      const mockPresenter = {
+        viewModel: { sponsors: [] },
+      };
+      getSponsorsUseCase.execute.mockResolvedValue(undefined);
+
+      const result = await service.getSponsors();
+
+      expect(result).toEqual(mockPresenter.viewModel);
+      expect(getSponsorsUseCase.execute).toHaveBeenCalledWith(undefined, expect.any(Object));
+    });
+  });
+
+  describe('createSponsor', () => {
+    it('should create sponsor successfully', async () => {
+      const input = { name: 'Test Sponsor', contactEmail: 'test@example.com' };
+      const mockPresenter = {
+        viewModel: { id: 'sponsor-1', name: 'Test Sponsor' },
+      };
+      createSponsorUseCase.execute.mockResolvedValue(undefined);
+
+      const result = await service.createSponsor(input);
+
+      expect(result).toEqual(mockPresenter.viewModel);
+      expect(createSponsorUseCase.execute).toHaveBeenCalledWith(input, expect.any(Object));
+    });
+  });
+
+  describe('getSponsorDashboard', () => {
+    it('should return sponsor dashboard', async () => {
+      const params = { sponsorId: 'sponsor-1' };
+      const mockPresenter = {
+        viewModel: { sponsorId: 'sponsor-1', metrics: {}, sponsoredLeagues: [] },
+      };
+      getSponsorDashboardUseCase.execute.mockResolvedValue(undefined);
+
+      const result = await service.getSponsorDashboard(params);
+
+      expect(result).toEqual(mockPresenter.viewModel);
+      expect(getSponsorDashboardUseCase.execute).toHaveBeenCalledWith(params, expect.any(Object));
+    });
+  });
+
+  describe('getSponsorSponsorships', () => {
+    it('should return sponsor sponsorships', async () => {
+      const params = { sponsorId: 'sponsor-1' };
+      const mockPresenter = {
+        viewModel: { sponsorId: 'sponsor-1', sponsorships: [] },
+      };
+      getSponsorSponsorshipsUseCase.execute.mockResolvedValue(undefined);
+
+      const result = await service.getSponsorSponsorships(params);
+
+      expect(result).toEqual(mockPresenter.viewModel);
+      expect(getSponsorSponsorshipsUseCase.execute).toHaveBeenCalledWith(params, expect.any(Object));
+    });
+  });
+
+  describe('getSponsor', () => {
+    it('should return sponsor when found', async () => {
+      const sponsorId = 'sponsor-1';
+      const mockSponsor = { id: sponsorId, name: 'Test Sponsor' };
+      getSponsorUseCase.execute.mockResolvedValue(Result.ok(mockSponsor));
+
+      const result = await service.getSponsor(sponsorId);
+
+      expect(result).toEqual(mockSponsor);
+      expect(getSponsorUseCase.execute).toHaveBeenCalledWith({ sponsorId });
+    });
+
+    it('should return null when sponsor not found', async () => {
+      const sponsorId = 'sponsor-1';
+      getSponsorUseCase.execute.mockResolvedValue(Result.err({ code: 'NOT_FOUND' }));
+
+      const result = await service.getSponsor(sponsorId);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getPendingSponsorshipRequests', () => {
+    it('should return pending sponsorship requests', async () => {
+      const params = { entityType: 'season' as const, entityId: 'season-1' };
+      const mockResult = {
+        entityType: 'season',
+        entityId: 'season-1',
+        requests: [],
+        totalCount: 0,
+      };
+      getPendingSponsorshipRequestsUseCase.execute.mockResolvedValue(Result.ok(mockResult));
+
+      const result = await service.getPendingSponsorshipRequests(params);
+
+      expect(result).toEqual(mockResult);
+      expect(getPendingSponsorshipRequestsUseCase.execute).toHaveBeenCalledWith(params);
+    });
+
+    it('should return empty result on error', async () => {
+      const params = { entityType: 'season' as const, entityId: 'season-1' };
+      getPendingSponsorshipRequestsUseCase.execute.mockResolvedValue(Result.err({ code: 'REPOSITORY_ERROR' }));
+
+      const result = await service.getPendingSponsorshipRequests(params);
+
+      expect(result).toEqual({
+        entityType: 'season',
+        entityId: 'season-1',
+        requests: [],
+        totalCount: 0,
+      });
+    });
+  });
+
+  describe('acceptSponsorshipRequest', () => {
+    it('should accept sponsorship request successfully', async () => {
+      const requestId = 'request-1';
+      const respondedBy = 'user-1';
+      const mockResult = {
+        requestId,
+        sponsorshipId: 'sponsorship-1',
+        status: 'accepted' as const,
+        acceptedAt: new Date(),
+        platformFee: 10,
+        netAmount: 90,
+      };
+      acceptSponsorshipRequestUseCase.execute.mockResolvedValue(Result.ok(mockResult));
+
+      const result = await service.acceptSponsorshipRequest(requestId, respondedBy);
+
+      expect(result).toEqual(mockResult);
+      expect(acceptSponsorshipRequestUseCase.execute).toHaveBeenCalledWith({ requestId, respondedBy });
+    });
+
+    it('should return null on error', async () => {
+      const requestId = 'request-1';
+      const respondedBy = 'user-1';
+      acceptSponsorshipRequestUseCase.execute.mockResolvedValue(Result.err({ code: 'NOT_FOUND' }));
+
+      const result = await service.acceptSponsorshipRequest(requestId, respondedBy);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('rejectSponsorshipRequest', () => {
+    it('should reject sponsorship request successfully', async () => {
+      const requestId = 'request-1';
+      const respondedBy = 'user-1';
+      const reason = 'Not interested';
+      const mockResult = {
+        requestId,
+        status: 'rejected' as const,
+        rejectedAt: new Date(),
+        reason,
+      };
+      rejectSponsorshipRequestUseCase.execute.mockResolvedValue(Result.ok(mockResult));
+
+      const result = await service.rejectSponsorshipRequest(requestId, respondedBy, reason);
+
+      expect(result).toEqual(mockResult);
+      expect(rejectSponsorshipRequestUseCase.execute).toHaveBeenCalledWith({ requestId, respondedBy, reason });
+    });
+
+    it('should return null on error', async () => {
+      const requestId = 'request-1';
+      const respondedBy = 'user-1';
+      rejectSponsorshipRequestUseCase.execute.mockResolvedValue(Result.err({ code: 'NOT_FOUND' }));
+
+      const result = await service.rejectSponsorshipRequest(requestId, respondedBy);
+
+      expect(result).toBeNull();
+    });
+  });
+});

apps/api/src/domain/sponsor/SponsorService.ts

@@ -11,11 +11,6 @@ import { GetSponsorOutputDTO } from './dtos/GetSponsorOutputDTO';
 import { GetPendingSponsorshipRequestsOutputDTO } from './dtos/GetPendingSponsorshipRequestsOutputDTO';
 import { AcceptSponsorshipRequestInputDTO } from './dtos/AcceptSponsorshipRequestInputDTO';
 import { RejectSponsorshipRequestInputDTO } from './dtos/RejectSponsorshipRequestInputDTO';
-import { SponsorDTO } from './dtos/SponsorDTO';
-import { SponsorDashboardMetricsDTO } from './dtos/SponsorDashboardMetricsDTO';
-import { SponsoredLeagueDTO } from './dtos/SponsoredLeagueDTO';
-import { SponsorDashboardInvestmentDTO } from './dtos/SponsorDashboardInvestmentDTO';
-import { SponsorshipDetailDTO } from './dtos/SponsorshipDetailDTO';
 
 // Use cases
 import { GetSponsorshipPricingUseCase } from '@core/racing/application/use-cases/GetSponsorshipPricingUseCase';
@@ -24,16 +19,13 @@ import { CreateSponsorUseCase } from '@core/racing/application/use-cases/CreateS
 import { GetSponsorDashboardUseCase } from '@core/racing/application/use-cases/GetSponsorDashboardUseCase';
 import { GetSponsorSponsorshipsUseCase } from '@core/racing/application/use-cases/GetSponsorSponsorshipsUseCase';
 import { GetSponsorUseCase } from '@core/racing/application/use-cases/GetSponsorUseCase';
-import { GetPendingSponsorshipRequestsUseCase } from '@core/racing/application/use-cases/GetPendingSponsorshipRequestsUseCase';
+import { GetPendingSponsorshipRequestsUseCase, GetPendingSponsorshipRequestsDTO } from '@core/racing/application/use-cases/GetPendingSponsorshipRequestsUseCase';
 import { AcceptSponsorshipRequestUseCase } from '@core/racing/application/use-cases/AcceptSponsorshipRequestUseCase';
 import { RejectSponsorshipRequestUseCase } from '@core/racing/application/use-cases/RejectSponsorshipRequestUseCase';
+import type { SponsorableEntityType } from '@core/racing/domain/entities/SponsorshipRequest';
+import type { AcceptSponsorshipRequestResultDTO } from '@core/racing/application/dtos/AcceptSponsorshipRequestResultDTO';
+import type { RejectSponsorshipRequestResultDTO } from '@core/racing/application/use-cases/RejectSponsorshipRequestUseCase';
 
-// Presenters
-import { GetSponsorshipPricingPresenter } from './presenters/GetSponsorshipPricingPresenter';
-import { GetSponsorsPresenter } from './presenters/GetSponsorsPresenter';
-import { CreateSponsorPresenter } from './presenters/CreateSponsorPresenter';
-import { GetSponsorDashboardPresenter } from './presenters/GetSponsorDashboardPresenter';
-import { GetSponsorSponsorshipsPresenter } from './presenters/GetSponsorSponsorshipsPresenter';
 
 // Tokens
 import { GET_SPONSORSHIP_PRICING_USE_CASE_TOKEN, GET_SPONSORS_USE_CASE_TOKEN, CREATE_SPONSOR_USE_CASE_TOKEN, GET_SPONSOR_DASHBOARD_USE_CASE_TOKEN, GET_SPONSOR_SPONSORSHIPS_USE_CASE_TOKEN, GET_SPONSOR_USE_CASE_TOKEN, GET_PENDING_SPONSORSHIP_REQUESTS_USE_CASE_TOKEN, ACCEPT_SPONSORSHIP_REQUEST_USE_CASE_TOKEN, REJECT_SPONSORSHIP_REQUEST_USE_CASE_TOKEN, LOGGER_TOKEN } from './SponsorProviders';
@@ -57,41 +49,56 @@ export class SponsorService {
   async getEntitySponsorshipPricing(): Promise<GetEntitySponsorshipPricingResultDTO> {
     this.logger.debug('[SponsorService] Fetching sponsorship pricing.');
 
-    const presenter = new GetSponsorshipPricingPresenter();
-    await this.getSponsorshipPricingUseCase.execute(undefined, presenter);
-    return presenter.viewModel;
+    const result = await this.getSponsorshipPricingUseCase.execute();
+    if (result.isErr()) {
+      this.logger.error('[SponsorService] Failed to fetch sponsorship pricing.', result.error);
+      return { entityType: 'season', entityId: '', pricing: [] };
+    }
+    return result.value as GetEntitySponsorshipPricingResultDTO;
   }
 
   async getSponsors(): Promise<GetSponsorsOutputDTO> {
     this.logger.debug('[SponsorService] Fetching sponsors.');
 
-    const presenter = new GetSponsorsPresenter();
-    await this.getSponsorsUseCase.execute(undefined, presenter);
-    return presenter.viewModel;
+    const result = await this.getSponsorsUseCase.execute();
+    if (result.isErr()) {
+      this.logger.error('[SponsorService] Failed to fetch sponsors.', result.error);
+      return { sponsors: [] };
+    }
+    return result.value as GetSponsorsOutputDTO;
   }
 
   async createSponsor(input: CreateSponsorInputDTO): Promise<CreateSponsorOutputDTO> {
     this.logger.debug('[SponsorService] Creating sponsor.', { input });
 
-    const presenter = new CreateSponsorPresenter();
-    await this.createSponsorUseCase.execute(input, presenter);
-    return presenter.viewModel;
+    const result = await this.createSponsorUseCase.execute(input);
+    if (result.isErr()) {
+      this.logger.error('[SponsorService] Failed to create sponsor.', result.error);
+      throw new Error(result.error.details?.message || 'Failed to create sponsor');
+    }
+    return result.value as CreateSponsorOutputDTO;
   }
 
   async getSponsorDashboard(params: GetSponsorDashboardQueryParamsDTO): Promise<SponsorDashboardDTO | null> {
     this.logger.debug('[SponsorService] Fetching sponsor dashboard.', { params });
 
-    const presenter = new GetSponsorDashboardPresenter();
-    await this.getSponsorDashboardUseCase.execute(params, presenter);
-    return presenter.viewModel as SponsorDashboardDTO | null;
+    const result = await this.getSponsorDashboardUseCase.execute(params);
+    if (result.isErr()) {
+      this.logger.error('[SponsorService] Failed to fetch sponsor dashboard.', result.error);
+      return null;
+    }
+    return result.value as SponsorDashboardDTO | null;
   }
 
   async getSponsorSponsorships(params: GetSponsorSponsorshipsQueryParamsDTO): Promise<SponsorSponsorshipsDTO | null> {
     this.logger.debug('[SponsorService] Fetching sponsor sponsorships.', { params });
 
-    const presenter = new GetSponsorSponsorshipsPresenter();
-    await this.getSponsorSponsorshipsUseCase.execute(params, presenter);
-    return presenter.viewModel as SponsorSponsorshipsDTO | null;
+    const result = await this.getSponsorSponsorshipsUseCase.execute(params);
+    if (result.isErr()) {
+      this.logger.error('[SponsorService] Failed to fetch sponsor sponsorships.', result.error);
+      return null;
+    }
+    return result.value as SponsorSponsorshipsDTO | null;
   }
 
   async getSponsor(sponsorId: string): Promise<GetSponsorOutputDTO | null> {
@@ -105,18 +112,18 @@ export class SponsorService {
     return result.value as GetSponsorOutputDTO | null;
   }
 
-  async getPendingSponsorshipRequests(params: { entityType: string; entityId: string }): Promise<GetPendingSponsorshipRequestsOutputDTO> {
+  async getPendingSponsorshipRequests(params: { entityType: SponsorableEntityType; entityId: string }): Promise<GetPendingSponsorshipRequestsOutputDTO> {
     this.logger.debug('[SponsorService] Fetching pending sponsorship requests.', { params });
 
-    const result = await this.getPendingSponsorshipRequestsUseCase.execute(params as any);
+    const result = await this.getPendingSponsorshipRequestsUseCase.execute(params as GetPendingSponsorshipRequestsDTO);
     if (result.isErr()) {
       this.logger.error('[SponsorService] Failed to fetch pending sponsorship requests.', result.error);
-      return { entityType: params.entityType as any, entityId: params.entityId, requests: [], totalCount: 0 };
+      return { entityType: params.entityType, entityId: params.entityId, requests: [], totalCount: 0 };
     }
     return result.value as GetPendingSponsorshipRequestsOutputDTO;
   }
 
-  async acceptSponsorshipRequest(requestId: string, respondedBy: string): Promise<{ requestId: string; sponsorshipId: string; status: string; acceptedAt: Date; platformFee: number; netAmount: number } | null> {
+  async acceptSponsorshipRequest(requestId: string, respondedBy: string): Promise<AcceptSponsorshipRequestResultDTO | null> {
     this.logger.debug('[SponsorService] Accepting sponsorship request.', { requestId, respondedBy });
 
     const result = await this.acceptSponsorshipRequestUseCase.execute({ requestId, respondedBy });
@@ -127,7 +134,7 @@ export class SponsorService {
     return result.value;
   }
 
-  async rejectSponsorshipRequest(requestId: string, respondedBy: string, reason?: string): Promise<{ requestId: string; status: string; rejectedAt: Date } | null> {
+  async rejectSponsorshipRequest(requestId: string, respondedBy: string, reason?: string): Promise<RejectSponsorshipRequestResultDTO | null> {
     this.logger.debug('[SponsorService] Rejecting sponsorship request.', { requestId, respondedBy, reason });
 
     const result = await this.rejectSponsorshipRequestUseCase.execute({ requestId, respondedBy, reason });

apps/api/src/domain/sponsor/dtos/AcceptSponsorshipRequestInputDTO.ts

@@ -5,5 +5,5 @@ export class AcceptSponsorshipRequestInputDTO {
   @ApiProperty()
   @IsString()
   @IsNotEmpty()
-  respondedBy: string;
+  respondedBy!: string;
 }

apps/api/src/domain/sponsor/dtos/CreateSponsorInputDTO.ts

@@ -5,12 +5,12 @@ export class CreateSponsorInputDTO {
   @ApiProperty()
   @IsString()
   @IsNotEmpty()
-  name: string;
+  name!: string;
 
   @ApiProperty()
   @IsEmail()
   @IsNotEmpty()
-  contactEmail: string;
+  contactEmail!: string;
 
   @ApiProperty({ required: false })
   @IsOptional()

apps/api/src/domain/sponsor/presenters/CreateSponsorPresenter.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { CreateSponsorPresenter } from './CreateSponsorPresenter';
+
+describe('CreateSponsorPresenter', () => {
+  let presenter: CreateSponsorPresenter;
+
+  beforeEach(() => {
+    presenter = new CreateSponsorPresenter();
+  });
+
+  describe('reset', () => {
+    it('should reset the result to null', () => {
+      const mockResult = { id: 'sponsor-1', name: 'Test Sponsor' };
+      presenter.present(mockResult);
+      expect(presenter.viewModel).toEqual(mockResult);
+
+      presenter.reset();
+      expect(() => presenter.viewModel).toThrow('Presenter not presented');
+    });
+  });
+
+  describe('present', () => {
+    it('should store the result', () => {
+      const mockResult = { id: 'sponsor-1', name: 'Test Sponsor', contactEmail: 'test@example.com' };
+
+      presenter.present(mockResult);
+
+      expect(presenter.viewModel).toEqual(mockResult);
+    });
+  });
+
+  describe('getViewModel', () => {
+    it('should return null when not presented', () => {
+      expect(presenter.getViewModel()).toBeNull();
+    });
+
+    it('should return the result when presented', () => {
+      const mockResult = { id: 'sponsor-1', name: 'Test Sponsor' };
+      presenter.present(mockResult);
+
+      expect(presenter.getViewModel()).toEqual(mockResult);
+    });
+  });
+
+  describe('viewModel', () => {
+    it('should throw error when not presented', () => {
+      expect(() => presenter.viewModel).toThrow('Presenter not presented');
+    });
+
+    it('should return the result when presented', () => {
+      const mockResult = { id: 'sponsor-1', name: 'Test Sponsor' };
+      presenter.present(mockResult);
+
+      expect(presenter.viewModel).toEqual(mockResult);
+    });
+  });
+});

apps/api/src/domain/sponsor/presenters/GetEntitySponsorshipPricingPresenter.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { GetEntitySponsorshipPricingPresenter } from './GetEntitySponsorshipPricingPresenter';
+
+describe('GetEntitySponsorshipPricingPresenter', () => {
+  let presenter: GetEntitySponsorshipPricingPresenter;
+
+  beforeEach(() => {
+    presenter = new GetEntitySponsorshipPricingPresenter();
+  });
+
+  describe('reset', () => {
+    it('should reset the result to null', () => {
+      const mockResult = { entityType: 'season', entityId: 'season-1', pricing: [] };
+      presenter.present(mockResult);
+      expect(presenter.viewModel).toEqual(mockResult);
+
+      presenter.reset();
+      expect(() => presenter.viewModel).toThrow('Presenter not presented');
+    });
+  });
+
+  describe('present', () => {
+    it('should store the result', () => {
+      const mockResult = { entityType: 'season', entityId: 'season-1', pricing: [] };
+
+      presenter.present(mockResult);
+
+      expect(presenter.viewModel).toEqual(mockResult);
+    });
+  });
+
+  describe('getViewModel', () => {
+    it('should return null when not presented', () => {
+      expect(presenter.getViewModel()).toBeNull();
+    });
+
+    it('should return the result when presented', () => {
+      const mockResult = { entityType: 'season', entityId: 'season-1', pricing: [] };
+      presenter.present(mockResult);
+
+      expect(presenter.getViewModel()).toEqual(mockResult);
+    });
+  });
+
+  describe('viewModel', () => {
+    it('should throw error when not presented', () => {
+      expect(() => presenter.viewModel).toThrow('Presenter not presented');
+    });
+
+    it('should return the result when presented', () => {
+      const mockResult = { entityType: 'season', entityId: 'season-1', pricing: [] };
+      presenter.present(mockResult);
+
+      expect(presenter.viewModel).toEqual(mockResult);
+    });
+  });
+});

apps/api/src/domain/sponsor/presenters/GetSponsorDashboardPresenter.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { GetSponsorDashboardPresenter } from './GetSponsorDashboardPresenter';
+
+describe('GetSponsorDashboardPresenter', () => {
+  let presenter: GetSponsorDashboardPresenter;
+
+  beforeEach(() => {
+    presenter = new GetSponsorDashboardPresenter();
+  });
+
+  describe('reset', () => {
+    it('should reset the result to null', () => {
+      const mockResult = { sponsorId: 'sponsor-1', metrics: {}, sponsoredLeagues: [] };
+      presenter.present(mockResult);
+      expect(presenter.viewModel).toEqual(mockResult);
+
+      presenter.reset();
+      expect(() => presenter.viewModel).toThrow('Presenter not presented');
+    });
+  });
+
+  describe('present', () => {
+    it('should store the result', () => {
+      const mockResult = { sponsorId: 'sponsor-1', metrics: {}, sponsoredLeagues: [] };
+
+      presenter.present(mockResult);
+
+      expect(presenter.viewModel).toEqual(mockResult);
+    });
+  });
+
+  describe('getViewModel', () => {
+    it('should return null when not presented', () => {
+      expect(presenter.getViewModel()).toBeNull();
+    });
+
+    it('should return the result when presented', () => {
+      const mockResult = { sponsorId: 'sponsor-1', metrics: {}, sponsoredLeagues: [] };
+      presenter.present(mockResult);
+
+      expect(presenter.getViewModel()).toEqual(mockResult);
+    });
+  });
+
+  describe('viewModel', () => {
+    it('should throw error when not presented', () => {
+      expect(() => presenter.viewModel).toThrow('Presenter not presented');
+    });
+
+    it('should return the result when presented', () => {
+      const mockResult = { sponsorId: 'sponsor-1', metrics: {}, sponsoredLeagues: [] };
+      presenter.present(mockResult);
+
+      expect(presenter.viewModel).toEqual(mockResult);
+    });
+  });
+});

apps/api/src/domain/sponsor/presenters/GetSponsorSponsorshipsPresenter.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { GetSponsorSponsorshipsPresenter } from './GetSponsorSponsorshipsPresenter';
+
+describe('GetSponsorSponsorshipsPresenter', () => {
+  let presenter: GetSponsorSponsorshipsPresenter;
+
+  beforeEach(() => {
+    presenter = new GetSponsorSponsorshipsPresenter();
+  });
+
+  describe('reset', () => {
+    it('should reset the result to null', () => {
+      const mockResult = { sponsorId: 'sponsor-1', sponsorName: 'Test Sponsor', sponsorships: [] };
+      presenter.present(mockResult);
+      expect(presenter.viewModel).toEqual(mockResult);
+
+      presenter.reset();
+      expect(() => presenter.viewModel).toThrow('Presenter not presented');
+    });
+  });
+
+  describe('present', () => {
+    it('should store the result', () => {
+      const mockResult = { sponsorId: 'sponsor-1', sponsorName: 'Test Sponsor', sponsorships: [] };
+
+      presenter.present(mockResult);
+
+      expect(presenter.viewModel).toEqual(mockResult);
+    });
+  });
+
+  describe('getViewModel', () => {
+    it('should return null when not presented', () => {
+      expect(presenter.getViewModel()).toBeNull();
+    });
+
+    it('should return the result when presented', () => {
+      const mockResult = { sponsorId: 'sponsor-1', sponsorName: 'Test Sponsor', sponsorships: [] };
+      presenter.present(mockResult);
+
+      expect(presenter.getViewModel()).toEqual(mockResult);
+    });
+  });
+
+  describe('viewModel', () => {
+    it('should throw error when not presented', () => {
+      expect(() => presenter.viewModel).toThrow('Presenter not presented');
+    });
+
+    it('should return the result when presented', () => {
+      const mockResult = { sponsorId: 'sponsor-1', sponsorName: 'Test Sponsor', sponsorships: [] };
+      presenter.present(mockResult);
+
+      expect(presenter.viewModel).toEqual(mockResult);
+    });
+  });
+});

apps/api/src/domain/sponsor/presenters/GetSponsorsPresenter.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { GetSponsorsPresenter } from './GetSponsorsPresenter';
+
+describe('GetSponsorsPresenter', () => {
+  let presenter: GetSponsorsPresenter;
+
+  beforeEach(() => {
+    presenter = new GetSponsorsPresenter();
+  });
+
+  describe('reset', () => {
+    it('should reset the result to null', () => {
+      const mockResult = { sponsors: [] };
+      presenter.present(mockResult);
+      expect(presenter.viewModel).toEqual(mockResult);
+
+      presenter.reset();
+      expect(() => presenter.viewModel).toThrow('Presenter not presented');
+    });
+  });
+
+  describe('present', () => {
+    it('should store the result', () => {
+      const mockResult = {
+        sponsors: [
+          { id: 'sponsor-1', name: 'Sponsor One', contactEmail: 's1@example.com' },
+          { id: 'sponsor-2', name: 'Sponsor Two', contactEmail: 's2@example.com' },
+        ],
+      };
+
+      presenter.present(mockResult);
+
+      expect(presenter.viewModel).toEqual(mockResult);
+    });
+  });
+
+  describe('getViewModel', () => {
+    it('should return null when not presented', () => {
+      expect(presenter.getViewModel()).toBeNull();
+    });
+
+    it('should return the result when presented', () => {
+      const mockResult = { sponsors: [] };
+      presenter.present(mockResult);
+
+      expect(presenter.getViewModel()).toEqual(mockResult);
+    });
+  });
+
+  describe('viewModel', () => {
+    it('should throw error when not presented', () => {
+      expect(() => presenter.viewModel).toThrow('Presenter not presented');
+    });
+
+    it('should return the result when presented', () => {
+      const mockResult = { sponsors: [] };
+      presenter.present(mockResult);
+
+      expect(presenter.viewModel).toEqual(mockResult);
+    });
+  });
+});

apps/api/src/domain/sponsor/presenters/GetSponsorshipPricingPresenter.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { GetSponsorshipPricingPresenter } from './GetSponsorshipPricingPresenter';
+
+describe('GetSponsorshipPricingPresenter', () => {
+  let presenter: GetSponsorshipPricingPresenter;
+
+  beforeEach(() => {
+    presenter = new GetSponsorshipPricingPresenter();
+  });
+
+  describe('reset', () => {
+    it('should reset the result to null', () => {
+      const mockResult = { tiers: [] };
+      presenter.present(mockResult);
+      expect(presenter.viewModel).toEqual(mockResult);
+
+      presenter.reset();
+      expect(() => presenter.viewModel).toThrow('Presenter not presented');
+    });
+  });
+
+  describe('present', () => {
+    it('should store the result', () => {
+      const mockResult = { tiers: [] };
+
+      presenter.present(mockResult);
+
+      expect(presenter.viewModel).toEqual(mockResult);
+    });
+  });
+
+  describe('getViewModel', () => {
+    it('should return null when not presented', () => {
+      expect(presenter.getViewModel()).toBeNull();
+    });
+
+    it('should return the result when presented', () => {
+      const mockResult = { tiers: [] };
+      presenter.present(mockResult);
+
+      expect(presenter.getViewModel()).toEqual(mockResult);
+    });
+  });
+
+  describe('viewModel', () => {
+    it('should throw error when not presented', () => {
+      expect(() => presenter.viewModel).toThrow('Presenter not presented');
+    });
+
+    it('should return the result when presented', () => {
+      const mockResult = { tiers: [] };
+      presenter.present(mockResult);
+
+      expect(presenter.viewModel).toEqual(mockResult);
+    });
+  });
+});