refactor

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

@@ -0,0 +1,48 @@
+import { Controller, Get, Post, Body, HttpCode, HttpStatus, Param } from '@nestjs/common';
+import { ApiTags, ApiResponse, ApiOperation } from '@nestjs/swagger';
+import { SponsorService } from './SponsorService';
+import { GetEntitySponsorshipPricingResultDto, GetSponsorsOutput, CreateSponsorInput, CreateSponsorOutput, GetSponsorDashboardQueryParams, SponsorDashboardDTO, GetSponsorSponsorshipsQueryParams, SponsorSponsorshipsDTO } from './dto/SponsorDto';
+
+@ApiTags('sponsors')
+@Controller('sponsors')
+export class SponsorController {
+  constructor(private readonly sponsorService: SponsorService) {}
+
+  @Get('pricing')
+  @ApiOperation({ summary: 'Get sponsorship pricing for an entity' })
+  @ApiResponse({ status: 200, description: 'Sponsorship pricing', type: GetEntitySponsorshipPricingResultDto })
+  async getEntitySponsorshipPricing(): Promise<GetEntitySponsorshipPricingResultDto> {
+    return this.sponsorService.getEntitySponsorshipPricing();
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'Get all sponsors' })
+  @ApiResponse({ status: 200, description: 'List of sponsors', type: GetSponsorsOutput })
+  async getSponsors(): Promise<GetSponsorsOutput> {
+    return this.sponsorService.getSponsors();
+  }
+
+  @Post()
+  @HttpCode(HttpStatus.CREATED)
+  @ApiOperation({ summary: 'Create a new sponsor' })
+  @ApiResponse({ status: 201, description: 'Sponsor created', type: CreateSponsorOutput })
+  async createSponsor(@Body() input: CreateSponsorInput): Promise<CreateSponsorOutput> {
+    return this.sponsorService.createSponsor(input);
+  }
+
+  // Add other Sponsor endpoints here based on other presenters
+  @Get('dashboard/:sponsorId')
+  @ApiOperation({ summary: 'Get sponsor dashboard metrics and sponsored leagues' })
+  @ApiResponse({ status: 200, description: 'Sponsor dashboard data', type: SponsorDashboardDTO })
+  @ApiResponse({ status: 404, description: 'Sponsor not found' })
+  async getSponsorDashboard(@Param('sponsorId') sponsorId: string): Promise<SponsorDashboardDTO | null> {
+    return this.sponsorService.getSponsorDashboard({ sponsorId });
+  }
+  @Get(':sponsorId/sponsorships')
+  @ApiOperation({ summary: 'Get all sponsorships for a given sponsor' })
+  @ApiResponse({ status: 200, description: 'List of sponsorships', type: SponsorSponsorshipsDTO })
+  @ApiResponse({ status: 404, description: 'Sponsor not found' })
+  async getSponsorSponsorships(@Param('sponsorId') sponsorId: string): Promise<SponsorSponsorshipsDTO | null> {
+    return this.sponsorService.getSponsorSponsorships({ sponsorId });
+  }
+}

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

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { SponsorService } from './SponsorService';
+import { SponsorController } from './SponsorController';
+import { SponsorProviders } from './SponsorProviders';
+
+@Module({
+  controllers: [SponsorController],
+  providers: SponsorProviders,
+  exports: [SponsorService],
+})
+export class SponsorModule {}

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

@@ -0,0 +1,134 @@
+import { Provider } from '@nestjs/common';
+import { SponsorService } from './SponsorService';
+
+// Import core interfaces
+import { ISponsorRepository } from '@core/racing/domain/repositories/ISponsorRepository';
+import { ISeasonSponsorshipRepository } from '@core/racing/domain/repositories/ISeasonSponsorshipRepository';
+import { ISeasonRepository } from '@core/racing/domain/repositories/ISeasonRepository';
+import { ILeagueRepository } from '@core/racing/domain/repositories/ILeagueRepository';
+import { ILeagueMembershipRepository } from '@core/racing/domain/repositories/ILeagueMembershipRepository';
+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 type { Logger } from '@core/shared/application';
+
+// Import use cases
+import { GetSponsorshipPricingUseCase } from '@core/racing/application/use-cases/GetSponsorshipPricingUseCase';
+import { GetSponsorsUseCase } from '@core/racing/application/use-cases/GetSponsorsUseCase';
+import { CreateSponsorUseCase } from '@core/racing/application/use-cases/CreateSponsorUseCase';
+import { GetSponsorDashboardUseCase } from '@core/racing/application/use-cases/GetSponsorDashboardUseCase';
+import { GetSponsorSponsorshipsUseCase } from '@core/racing/application/use-cases/GetSponsorSponsorshipsUseCase';
+import { GetEntitySponsorshipPricingUseCase } from '@core/racing/application/use-cases/GetEntitySponsorshipPricingUseCase';
+
+// Import concrete in-memory implementations
+import { InMemorySponsorRepository } from '@adapters/racing/persistence/inmemory/InMemorySponsorRepository';
+import { InMemorySeasonSponsorshipRepository } from '@adapters/racing/persistence/inmemory/InMemorySeasonSponsorshipRepository';
+import { InMemorySeasonRepository } from '@adapters/racing/persistence/inmemory/InMemorySeasonRepository';
+import { InMemoryLeagueRepository } from '@adapters/racing/persistence/inmemory/InMemoryLeagueRepository';
+import { InMemoryLeagueMembershipRepository } from '@adapters/racing/persistence/inmemory/InMemoryLeagueMembershipRepository';
+import { InMemoryRaceRepository } from '@adapters/racing/persistence/inmemory/InMemoryRaceRepository';
+import { InMemorySponsorshipPricingRepository } from '@adapters/racing/persistence/inmemory/InMemorySponsorshipPricingRepository';
+import { InMemorySponsorshipRequestRepository } from '@adapters/racing/persistence/inmemory/InMemorySponsorshipRequestRepository';
+import { ConsoleLogger } from '@adapters/logging/ConsoleLogger';
+
+// Define injection tokens
+export const SPONSOR_REPOSITORY_TOKEN = 'ISponsorRepository';
+export const SEASON_SPONSORSHIP_REPOSITORY_TOKEN = 'ISeasonSponsorshipRepository';
+export const SEASON_REPOSITORY_TOKEN = 'ISeasonRepository';
+export const LEAGUE_REPOSITORY_TOKEN = 'ILeagueRepository';
+export const LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN = 'ILeagueMembershipRepository';
+export const RACE_REPOSITORY_TOKEN = 'IRaceRepository';
+export const SPONSORSHIP_PRICING_REPOSITORY_TOKEN = 'ISponsorshipPricingRepository';
+export const SPONSORSHIP_REQUEST_REPOSITORY_TOKEN = 'ISponsorshipRequestRepository';
+export const LOGGER_TOKEN = 'Logger';
+
+// Use case tokens
+export const GET_SPONSORSHIP_PRICING_USE_CASE_TOKEN = 'GetSponsorshipPricingUseCase';
+export const GET_SPONSORS_USE_CASE_TOKEN = 'GetSponsorsUseCase';
+export const CREATE_SPONSOR_USE_CASE_TOKEN = 'CreateSponsorUseCase';
+export const GET_SPONSOR_DASHBOARD_USE_CASE_TOKEN = 'GetSponsorDashboardUseCase';
+export const GET_SPONSOR_SPONSORSHIPS_USE_CASE_TOKEN = 'GetSponsorSponsorshipsUseCase';
+export const GET_ENTITY_SPONSORSHIP_PRICING_USE_CASE_TOKEN = 'GetEntitySponsorshipPricingUseCase';
+
+export const SponsorProviders: Provider[] = [
+  SponsorService,
+  // Repositories
+  {
+    provide: SPONSOR_REPOSITORY_TOKEN,
+    useFactory: (logger: Logger) => new InMemorySponsorRepository(logger),
+    inject: [LOGGER_TOKEN],
+  },
+  {
+    provide: SEASON_SPONSORSHIP_REPOSITORY_TOKEN,
+    useFactory: (logger: Logger) => new InMemorySeasonSponsorshipRepository(logger),
+    inject: [LOGGER_TOKEN],
+  },
+  {
+    provide: SEASON_REPOSITORY_TOKEN,
+    useFactory: (logger: Logger) => new InMemorySeasonRepository(logger),
+    inject: [LOGGER_TOKEN],
+  },
+  {
+    provide: LEAGUE_REPOSITORY_TOKEN,
+    useFactory: (logger: Logger) => new InMemoryLeagueRepository(logger),
+    inject: [LOGGER_TOKEN],
+  },
+  {
+    provide: LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN,
+    useFactory: (logger: Logger) => new InMemoryLeagueMembershipRepository(logger),
+    inject: [LOGGER_TOKEN],
+  },
+  {
+    provide: RACE_REPOSITORY_TOKEN,
+    useFactory: (logger: Logger) => new InMemoryRaceRepository(logger),
+    inject: [LOGGER_TOKEN],
+  },
+  {
+    provide: SPONSORSHIP_PRICING_REPOSITORY_TOKEN,
+    useFactory: (logger: Logger) => new InMemorySponsorshipPricingRepository(logger),
+    inject: [LOGGER_TOKEN],
+  },
+  {
+    provide: SPONSORSHIP_REQUEST_REPOSITORY_TOKEN,
+    useFactory: (logger: Logger) => new InMemorySponsorshipRequestRepository(logger),
+    inject: [LOGGER_TOKEN],
+  },
+  {
+    provide: LOGGER_TOKEN,
+    useClass: ConsoleLogger,
+  },
+  // Use cases
+  {
+    provide: GET_SPONSORSHIP_PRICING_USE_CASE_TOKEN,
+    useFactory: () => new GetSponsorshipPricingUseCase(),
+    inject: [],
+  },
+  {
+    provide: GET_SPONSORS_USE_CASE_TOKEN,
+    useFactory: (sponsorRepo: ISponsorRepository) => new GetSponsorsUseCase(sponsorRepo),
+    inject: [SPONSOR_REPOSITORY_TOKEN],
+  },
+  {
+    provide: CREATE_SPONSOR_USE_CASE_TOKEN,
+    useFactory: (sponsorRepo: ISponsorRepository) => new CreateSponsorUseCase(sponsorRepo),
+    inject: [SPONSOR_REPOSITORY_TOKEN],
+  },
+  {
+    provide: GET_SPONSOR_DASHBOARD_USE_CASE_TOKEN,
+    useFactory: (sponsorRepo: ISponsorRepository, seasonSponsorshipRepo: ISeasonSponsorshipRepository, seasonRepo: ISeasonRepository, leagueRepo: ILeagueRepository, leagueMembershipRepo: ILeagueMembershipRepository, raceRepo: IRaceRepository) =>
+      new GetSponsorDashboardUseCase(sponsorRepo, seasonSponsorshipRepo, seasonRepo, leagueRepo, leagueMembershipRepo, raceRepo),
+    inject: [SPONSOR_REPOSITORY_TOKEN, SEASON_SPONSORSHIP_REPOSITORY_TOKEN, SEASON_REPOSITORY_TOKEN, LEAGUE_REPOSITORY_TOKEN, LEAGUE_MEMBERSHIP_REPOSITORY_TOKEN, RACE_REPOSITORY_TOKEN],
+  },
+  {
+    provide: GET_SPONSOR_SPONSORSHIPS_USE_CASE_TOKEN,
+    useFactory: (sponsorRepo: ISponsorRepository, seasonSponsorshipRepo: ISeasonSponsorshipRepository, seasonRepo: ISeasonRepository, raceRepo: IRaceRepository) =>
+      new GetSponsorSponsorshipsUseCase(sponsorRepo, seasonSponsorshipRepo, seasonRepo, raceRepo),
+    inject: [SPONSOR_REPOSITORY_TOKEN, SEASON_SPONSORSHIP_REPOSITORY_TOKEN, SEASON_REPOSITORY_TOKEN, RACE_REPOSITORY_TOKEN],
+  },
+  {
+    provide: GET_ENTITY_SPONSORSHIP_PRICING_USE_CASE_TOKEN,
+    useFactory: (sponsorshipPricingRepo: ISponsorshipPricingRepository, sponsorshipRequestRepo: ISponsorshipRequestRepository, seasonSponsorshipRepo: ISeasonSponsorshipRepository, logger: Logger) =>
+      new GetEntitySponsorshipPricingUseCase(sponsorshipPricingRepo, sponsorshipRequestRepo, seasonSponsorshipRepo, logger),
+    inject: [SPONSORSHIP_PRICING_REPOSITORY_TOKEN, SPONSORSHIP_REQUEST_REPOSITORY_TOKEN, SEASON_SPONSORSHIP_REPOSITORY_TOKEN, LOGGER_TOKEN],
+  },
+];

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

@@ -0,0 +1,72 @@
+import { Injectable, Inject } from '@nestjs/common';
+import { GetEntitySponsorshipPricingResultDto, GetSponsorsOutput, CreateSponsorInput, CreateSponsorOutput, GetSponsorDashboardQueryParams, SponsorDashboardDTO, GetSponsorSponsorshipsQueryParams, SponsorSponsorshipsDTO, SponsorDto, SponsorDashboardMetricsDTO, SponsoredLeagueDTO, SponsorDashboardInvestmentDTO, SponsorshipDetailDTO } from './dto/SponsorDto';
+
+// Use cases
+import { GetSponsorshipPricingUseCase } from '@core/racing/application/use-cases/GetSponsorshipPricingUseCase';
+import { GetSponsorsUseCase } from '@core/racing/application/use-cases/GetSponsorsUseCase';
+import { CreateSponsorUseCase } from '@core/racing/application/use-cases/CreateSponsorUseCase';
+import { GetSponsorDashboardUseCase } from '@core/racing/application/use-cases/GetSponsorDashboardUseCase';
+import { GetSponsorSponsorshipsUseCase } from '@core/racing/application/use-cases/GetSponsorSponsorshipsUseCase';
+
+// 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, LOGGER_TOKEN } from './SponsorProviders';
+import type { Logger } from '@core/shared/application';
+
+@Injectable()
+export class SponsorService {
+  constructor(
+    @Inject(GET_SPONSORSHIP_PRICING_USE_CASE_TOKEN) private readonly getSponsorshipPricingUseCase: GetSponsorshipPricingUseCase,
+    @Inject(GET_SPONSORS_USE_CASE_TOKEN) private readonly getSponsorsUseCase: GetSponsorsUseCase,
+    @Inject(CREATE_SPONSOR_USE_CASE_TOKEN) private readonly createSponsorUseCase: CreateSponsorUseCase,
+    @Inject(GET_SPONSOR_DASHBOARD_USE_CASE_TOKEN) private readonly getSponsorDashboardUseCase: GetSponsorDashboardUseCase,
+    @Inject(GET_SPONSOR_SPONSORSHIPS_USE_CASE_TOKEN) private readonly getSponsorSponsorshipsUseCase: GetSponsorSponsorshipsUseCase,
+    @Inject(LOGGER_TOKEN) private readonly logger: Logger,
+  ) {}
+
+  async getEntitySponsorshipPricing(): Promise<GetEntitySponsorshipPricingResultDto> {
+    this.logger.debug('[SponsorService] Fetching sponsorship pricing.');
+
+    const presenter = new GetSponsorshipPricingPresenter();
+    await this.getSponsorshipPricingUseCase.execute(undefined, presenter);
+    return presenter.viewModel;
+  }
+
+  async getSponsors(): Promise<GetSponsorsOutput> {
+    this.logger.debug('[SponsorService] Fetching sponsors.');
+
+    const presenter = new GetSponsorsPresenter();
+    await this.getSponsorsUseCase.execute(undefined, presenter);
+    return presenter.viewModel;
+  }
+
+  async createSponsor(input: CreateSponsorInput): Promise<CreateSponsorOutput> {
+    this.logger.debug('[SponsorService] Creating sponsor.', { input });
+
+    const presenter = new CreateSponsorPresenter();
+    await this.createSponsorUseCase.execute(input, presenter);
+    return presenter.viewModel;
+  }
+
+  async getSponsorDashboard(params: GetSponsorDashboardQueryParams): 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;
+  }
+
+  async getSponsorSponsorships(params: GetSponsorSponsorshipsQueryParams): 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;
+  }
+}

apps/api/src/domain/sponsor/dto/SponsorDto.ts

@@ -0,0 +1,299 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsString, IsNotEmpty, IsNumber, IsEnum, IsOptional, IsDate, IsBoolean, IsUrl, IsEmail } from 'class-validator';
+
+export class SponsorshipPricingItemDto {
+  @ApiProperty()
+  @IsString()
+  id: string;
+
+  @ApiProperty()
+  @IsString()
+  level: string;
+
+  @ApiProperty()
+  @IsNumber()
+  price: number;
+
+  @ApiProperty()
+  @IsString()
+  currency: string;
+}
+
+export class GetEntitySponsorshipPricingResultDto {
+  @ApiProperty({ type: [SponsorshipPricingItemDto] })
+  pricing: SponsorshipPricingItemDto[];
+}
+
+export class SponsorDto {
+  @ApiProperty()
+  @IsString()
+  id: string;
+
+  @ApiProperty()
+  @IsString()
+  @IsNotEmpty()
+  name: string;
+
+  @ApiProperty()
+  @IsString()
+  @IsEmail()
+  @IsNotEmpty()
+  contactEmail: string;
+
+  @ApiProperty({ required: false })
+  @IsOptional()
+  @IsString()
+  @IsUrl()
+  websiteUrl?: string;
+
+  @ApiProperty({ required: false })
+  @IsOptional()
+  @IsString()
+  @IsUrl()
+  logoUrl?: string;
+
+  @ApiProperty()
+  @IsDate()
+  createdAt: Date;
+}
+
+export class GetSponsorsOutput {
+  @ApiProperty({ type: [SponsorDto] })
+  sponsors: SponsorDto[];
+}
+
+export class CreateSponsorInput {
+  @ApiProperty()
+  @IsString()
+  @IsNotEmpty()
+  name: string;
+
+  @ApiProperty()
+  @IsEmail()
+  @IsNotEmpty()
+  contactEmail: string;
+
+  @ApiProperty({ required: false })
+  @IsOptional()
+  @IsString()
+  @IsUrl()
+  websiteUrl?: string;
+
+  @ApiProperty({ required: false })
+  @IsOptional()
+  @IsString()
+  @IsUrl()
+  logoUrl?: string;
+}
+
+export class CreateSponsorOutput {
+  @ApiProperty({ type: SponsorDto })
+  sponsor: SponsorDto;
+}
+
+export class GetSponsorDashboardQueryParams {
+  @ApiProperty()
+  @IsString()
+  sponsorId: string;
+}
+
+export class SponsoredLeagueDTO {
+  @ApiProperty()
+  @IsString()
+  id: string;
+
+  @ApiProperty()
+  @IsString()
+  name: string;
+
+  @ApiProperty({ enum: ['main', 'secondary'] })
+  @IsEnum(['main', 'secondary'])
+  tier: 'main' | 'secondary';
+
+  @ApiProperty()
+  @IsNumber()
+  drivers: number;
+
+  @ApiProperty()
+  @IsNumber()
+  races: number;
+
+  @ApiProperty()
+  @IsNumber()
+  impressions: number;
+
+  @ApiProperty({ enum: ['active', 'upcoming', 'completed'] })
+  @IsEnum(['active', 'upcoming', 'completed'])
+  status: 'active' | 'upcoming' | 'completed';
+}
+
+export class SponsorDashboardMetricsDTO {
+  @ApiProperty()
+  @IsNumber()
+  impressions: number;
+
+  @ApiProperty()
+  @IsNumber()
+  impressionsChange: number;
+
+  @ApiProperty()
+  @IsNumber()
+  uniqueViewers: number;
+
+  @ApiProperty()
+  @IsNumber()
+  viewersChange: number;
+
+  @ApiProperty()
+  @IsNumber()
+  races: number;
+
+  @ApiProperty()
+  @IsNumber()
+  drivers: number;
+
+  @ApiProperty()
+  @IsNumber()
+  exposure: number;
+
+  @ApiProperty()
+  @IsNumber()
+  exposureChange: number;
+}
+
+export class SponsorDashboardInvestmentDTO {
+  @ApiProperty()
+  @IsNumber()
+  activeSponsorships: number;
+
+  @ApiProperty()
+  @IsNumber()
+  totalInvestment: number;
+
+  @ApiProperty()
+  @IsNumber()
+  costPerThousandViews: number;
+}
+
+export class SponsorDashboardDTO {
+  @ApiProperty()
+  @IsString()
+  sponsorId: string;
+
+  @ApiProperty()
+  @IsString()
+  sponsorName: string;
+
+  @ApiProperty({ type: SponsorDashboardMetricsDTO })
+  metrics: SponsorDashboardMetricsDTO;
+
+  @ApiProperty({ type: [SponsoredLeagueDTO] })
+  sponsoredLeagues: SponsoredLeagueDTO[];
+
+  @ApiProperty({ type: SponsorDashboardInvestmentDTO })
+  investment: SponsorDashboardInvestmentDTO;
+}
+
+export class GetSponsorSponsorshipsQueryParams {
+  @ApiProperty()
+  @IsString()
+  sponsorId: string;
+}
+
+export class SponsorshipDetailDTO {
+  @ApiProperty()
+  @IsString()
+  id: string;
+
+  @ApiProperty()
+  @IsString()
+  leagueId: string;
+
+  @ApiProperty()
+  @IsString()
+  leagueName: string;
+
+  @ApiProperty()
+  @IsString()
+  seasonId: string;
+
+  @ApiProperty()
+  @IsString()
+  seasonName: string;
+
+  @ApiProperty({ required: false })
+  @IsOptional()
+  @IsDate()
+  seasonStartDate?: Date;
+
+  @ApiProperty({ required: false })
+  @IsOptional()
+  @IsDate()
+  seasonEndDate?: Date;
+
+  @ApiProperty({ enum: ['main', 'secondary'] })
+  @IsEnum(['main', 'secondary'])
+  tier: 'main' | 'secondary';
+
+  @ApiProperty({ enum: ['pending', 'active', 'expired', 'cancelled'] })
+  @IsEnum(['pending', 'active', 'expired', 'cancelled'])
+  status: 'pending' | 'active' | 'expired' | 'cancelled';
+
+  @ApiProperty()
+  pricing: {
+    amount: number;
+    currency: string;
+  };
+
+  @ApiProperty()
+  platformFee: {
+    amount: number;
+    currency: string;
+  };
+
+  @ApiProperty()
+  netAmount: {
+    amount: number;
+    currency: string;
+  };
+
+  @ApiProperty()
+  metrics: {
+    drivers: number;
+    races: number;
+    completedRaces: number;
+    impressions: number;
+  };
+
+  @ApiProperty()
+  createdAt: Date;
+
+  @ApiProperty({ required: false })
+  @IsOptional()
+  @IsDate()
+  activatedAt?: Date;
+}
+
+export class SponsorSponsorshipsDTO {
+  @ApiProperty()
+  @IsString()
+  sponsorId: string;
+
+  @ApiProperty()
+  @IsString()
+  sponsorName: string;
+
+  @ApiProperty({ type: [SponsorshipDetailDTO] })
+  sponsorships: SponsorshipDetailDTO[];
+
+  @ApiProperty()
+  summary: {
+    totalSponsorships: number;
+    activeSponsorships: number;
+    totalInvestment: number;
+    totalPlatformFees: number;
+    currency: string;
+  };
+}
+
+// Add other DTOs for sponsor-related logic as needed

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

@@ -0,0 +1,22 @@
+import { CreateSponsorViewModel, CreateSponsorResultDTO, ICreateSponsorPresenter } from '@core/racing/application/presenters/ICreateSponsorPresenter';
+
+export class CreateSponsorPresenter implements ICreateSponsorPresenter {
+  private result: CreateSponsorViewModel | null = null;
+
+  reset() {
+    this.result = null;
+  }
+
+  present(dto: CreateSponsorResultDTO) {
+    this.result = dto;
+  }
+
+  getViewModel(): CreateSponsorViewModel | null {
+    return this.result;
+  }
+
+  get viewModel(): CreateSponsorViewModel {
+    if (!this.result) throw new Error('Presenter not presented');
+    return this.result;
+  }
+}

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

@@ -0,0 +1,22 @@
+import type { GetEntitySponsorshipPricingResultDTO } from '@core/racing/application/use-cases/GetEntitySponsorshipPricingUseCase';
+import type { IEntitySponsorshipPricingPresenter } from '@core/racing/application/presenters/IEntitySponsorshipPricingPresenter';
+
+export class GetEntitySponsorshipPricingPresenter implements IEntitySponsorshipPricingPresenter {
+  private result: GetEntitySponsorshipPricingResultDTO | null = null;
+
+  reset() {
+    this.result = null;
+  }
+
+  present(dto: GetEntitySponsorshipPricingResultDTO | null) {
+    this.result = dto;
+  }
+
+  getViewModel(): GetEntitySponsorshipPricingResultDTO | null {
+    return this.result;
+  }
+
+  get viewModel(): GetEntitySponsorshipPricingResultDTO | null {
+    return this.result;
+  }
+}

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

@@ -0,0 +1,22 @@
+import type { SponsorDashboardDTO } from '@core/racing/application/use-cases/GetSponsorDashboardUseCase';
+import type { ISponsorDashboardPresenter, SponsorDashboardViewModel } from '@core/racing/application/presenters/ISponsorDashboardPresenter';
+
+export class GetSponsorDashboardPresenter implements ISponsorDashboardPresenter {
+  private result: SponsorDashboardViewModel | null = null;
+
+  reset() {
+    this.result = null;
+  }
+
+  present(dto: SponsorDashboardDTO | null) {
+    this.result = dto;
+  }
+
+  getViewModel(): SponsorDashboardViewModel | null {
+    return this.result;
+  }
+
+  get viewModel(): SponsorDashboardViewModel | null {
+    return this.result;
+  }
+}

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

@@ -0,0 +1,22 @@
+import type { SponsorSponsorshipsDTO } from '@core/racing/application/use-cases/GetSponsorSponsorshipsUseCase';
+import type { ISponsorSponsorshipsPresenter, SponsorSponsorshipsViewModel } from '@core/racing/application/presenters/ISponsorSponsorshipsPresenter';
+
+export class GetSponsorSponsorshipsPresenter implements ISponsorSponsorshipsPresenter {
+  private result: SponsorSponsorshipsViewModel | null = null;
+
+  reset() {
+    this.result = null;
+  }
+
+  present(dto: SponsorSponsorshipsDTO | null) {
+    this.result = dto;
+  }
+
+  getViewModel(): SponsorSponsorshipsViewModel | null {
+    return this.result;
+  }
+
+  get viewModel(): SponsorSponsorshipsViewModel | null {
+    return this.result;
+  }
+}

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

@@ -0,0 +1,22 @@
+import { GetSponsorsViewModel, GetSponsorsResultDTO, IGetSponsorsPresenter } from '@core/racing/application/presenters/IGetSponsorsPresenter';
+
+export class GetSponsorsPresenter implements IGetSponsorsPresenter {
+  private result: GetSponsorsViewModel | null = null;
+
+  reset() {
+    this.result = null;
+  }
+
+  present(dto: GetSponsorsResultDTO) {
+    this.result = dto;
+  }
+
+  getViewModel(): GetSponsorsViewModel | null {
+    return this.result;
+  }
+
+  get viewModel(): GetSponsorsViewModel {
+    if (!this.result) throw new Error('Presenter not presented');
+    return this.result;
+  }
+}

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

@@ -0,0 +1,22 @@
+import { GetSponsorshipPricingViewModel, GetSponsorshipPricingResultDTO, IGetSponsorshipPricingPresenter } from '@core/racing/application/presenters/IGetSponsorshipPricingPresenter';
+
+export class GetSponsorshipPricingPresenter implements IGetSponsorshipPricingPresenter {
+  private result: GetSponsorshipPricingViewModel | null = null;
+
+  reset() {
+    this.result = null;
+  }
+
+  present(dto: GetSponsorshipPricingResultDTO) {
+    this.result = dto;
+  }
+
+  getViewModel(): GetSponsorshipPricingViewModel | null {
+    return this.result;
+  }
+
+  get viewModel(): GetSponsorshipPricingViewModel {
+    if (!this.result) throw new Error('Presenter not presented');
+    return this.result;
+  }
+}