wip

packages/racing/application/dto/LeagueScheduleDTO.ts

@@ -7,6 +7,7 @@ import { MonthlyRecurrencePattern } from '../../domain/value-objects/MonthlyRecu
 import type { RecurrenceStrategy } from '../../domain/value-objects/RecurrenceStrategy';
 import { RecurrenceStrategyFactory } from '../../domain/value-objects/RecurrenceStrategy';
 import { SeasonSchedule } from '../../domain/value-objects/SeasonSchedule';
+import { BusinessRuleViolationError } from '../errors/RacingApplicationError';
 
 export interface LeagueScheduleDTO {
   seasonStartDate: string;
@@ -53,24 +54,24 @@ export function leagueTimingsToScheduleDTO(
 
 export function scheduleDTOToSeasonSchedule(dto: LeagueScheduleDTO): SeasonSchedule {
   if (!dto.seasonStartDate) {
-    throw new Error('seasonStartDate is required');
+    throw new RacingApplicationError('seasonStartDate is required');
   }
   if (!dto.raceStartTime) {
-    throw new Error('raceStartTime is required');
+    throw new RacingApplicationError('raceStartTime is required');
   }
   if (!dto.timezoneId) {
-    throw new Error('timezoneId is required');
+    throw new RacingApplicationError('timezoneId is required');
   }
   if (!dto.recurrenceStrategy) {
-    throw new Error('recurrenceStrategy is required');
+    throw new RacingApplicationError('recurrenceStrategy is required');
   }
   if (!Number.isInteger(dto.plannedRounds) || dto.plannedRounds <= 0) {
-    throw new Error('plannedRounds must be a positive integer');
+    throw new RacingApplicationError('plannedRounds must be a positive integer');
   }
 
   const startDate = new Date(dto.seasonStartDate);
   if (Number.isNaN(startDate.getTime())) {
-    throw new Error(`seasonStartDate must be a valid date, got "${dto.seasonStartDate}"`);
+    throw new RacingApplicationError(`seasonStartDate must be a valid date, got "${dto.seasonStartDate}"`);
   }
 
   const timeOfDay = RaceTimeOfDay.fromString(dto.raceStartTime);
@@ -80,15 +81,15 @@ export function scheduleDTOToSeasonSchedule(dto: LeagueScheduleDTO): SeasonSched
 
   if (dto.recurrenceStrategy === 'weekly') {
     if (!dto.weekdays || dto.weekdays.length === 0) {
-      throw new Error('weekdays are required for weekly recurrence');
+      throw new RacingApplicationError('weekdays are required for weekly recurrence');
     }
     recurrence = RecurrenceStrategyFactory.weekly(new WeekdaySet(dto.weekdays));
   } else if (dto.recurrenceStrategy === 'everyNWeeks') {
     if (!dto.weekdays || dto.weekdays.length === 0) {
-      throw new Error('weekdays are required for everyNWeeks recurrence');
+      throw new RacingApplicationError('weekdays are required for everyNWeeks recurrence');
     }
     if (dto.intervalWeeks == null) {
-      throw new Error('intervalWeeks is required for everyNWeeks recurrence');
+      throw new RacingApplicationError('intervalWeeks is required for everyNWeeks recurrence');
     }
     recurrence = RecurrenceStrategyFactory.everyNWeeks(
       dto.intervalWeeks,
@@ -96,12 +97,12 @@ export function scheduleDTOToSeasonSchedule(dto: LeagueScheduleDTO): SeasonSched
     );
   } else if (dto.recurrenceStrategy === 'monthlyNthWeekday') {
     if (!dto.monthlyOrdinal || !dto.monthlyWeekday) {
-      throw new Error('monthlyOrdinal and monthlyWeekday are required for monthlyNthWeekday');
+      throw new RacingApplicationError('monthlyOrdinal and monthlyWeekday are required for monthlyNthWeekday');
     }
     const pattern = new MonthlyRecurrencePattern(dto.monthlyOrdinal, dto.monthlyWeekday);
     recurrence = RecurrenceStrategyFactory.monthlyNthWeekday(pattern);
   } else {
-    throw new Error(`Unknown recurrenceStrategy "${dto.recurrenceStrategy}"`);
+    throw new RacingApplicationError(`Unknown recurrenceStrategy "${dto.recurrenceStrategy}"`);
   }
 
   return new SeasonSchedule({

packages/racing/application/errors/RacingApplicationError.ts

@@ -0,0 +1,56 @@
+export abstract class RacingApplicationError extends Error {
+  readonly context = 'racing-application';
+
+  constructor(message: string) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export type RacingEntityType =
+  | 'race'
+  | 'league'
+  | 'team'
+  | 'season'
+  | 'sponsorship'
+  | 'sponsorshipRequest'
+  | 'driver'
+  | 'membership';
+
+export interface EntityNotFoundDetails {
+  entity: RacingEntityType;
+  id: string;
+}
+
+export class EntityNotFoundError extends RacingApplicationError {
+  readonly kind = 'not_found' as const;
+
+  constructor(public readonly details: EntityNotFoundDetails) {
+    super(`${details.entity} not found for id: ${details.id}`);
+  }
+}
+
+export type PermissionDeniedReason =
+  | 'NOT_LEAGUE_ADMIN'
+  | 'NOT_LEAGUE_OWNER'
+  | 'NOT_TEAM_OWNER'
+  | 'NOT_ACTIVE_MEMBER'
+  | 'NOT_MEMBER'
+  | 'TEAM_OWNER_CANNOT_LEAVE'
+  | 'UNAUTHORIZED';
+
+export class PermissionDeniedError extends RacingApplicationError {
+  readonly kind = 'forbidden' as const;
+
+  constructor(public readonly reason: PermissionDeniedReason, message?: string) {
+    super(message ?? `Permission denied: ${reason}`);
+  }
+}
+
+export class BusinessRuleViolationError extends RacingApplicationError {
+  readonly kind = 'conflict' as const;
+
+  constructor(message: string) {
+    super(message);
+  }
+}

packages/racing/application/use-cases/ApplyForSponsorshipUseCase.ts

@@ -11,6 +11,10 @@ import type { ISponsorshipRequestRepository } from '../../domain/repositories/IS
 import type { ISponsorshipPricingRepository } from '../../domain/repositories/ISponsorshipPricingRepository';
 import type { ISponsorRepository } from '../../domain/repositories/ISponsorRepository';
 import { Money, type Currency } from '../../domain/value-objects/Money';
+import {
+  EntityNotFoundError,
+  BusinessRuleViolationError,
+} from '../errors/RacingApplicationError';
 
 export interface ApplyForSponsorshipDTO {
   sponsorId: string;
@@ -39,23 +43,23 @@ export class ApplyForSponsorshipUseCase {
     // Validate sponsor exists
     const sponsor = await this.sponsorRepo.findById(dto.sponsorId);
     if (!sponsor) {
-      throw new Error('Sponsor not found');
+      throw new EntityNotFoundError({ entity: 'sponsor', id: dto.sponsorId });
     }
 
     // Check if entity accepts sponsorship applications
     const pricing = await this.sponsorshipPricingRepo.findByEntity(dto.entityType, dto.entityId);
     if (!pricing) {
-      throw new Error('This entity has not set up sponsorship pricing');
+      throw new BusinessRuleViolationError('This entity has not set up sponsorship pricing');
     }
 
     if (!pricing.acceptingApplications) {
-      throw new Error('This entity is not currently accepting sponsorship applications');
+      throw new RacingApplicationError('This entity is not currently accepting sponsorship applications');
     }
 
     // Check if the requested tier slot is available
     const slotAvailable = pricing.isSlotAvailable(dto.tier);
     if (!slotAvailable) {
-      throw new Error(`No ${dto.tier} sponsorship slots are available`);
+      throw new RacingApplicationError(`No ${dto.tier} sponsorship slots are available`);
     }
 
     // Check if sponsor already has a pending request for this entity
@@ -65,13 +69,13 @@ export class ApplyForSponsorshipUseCase {
       dto.entityId
     );
     if (hasPending) {
-      throw new Error('You already have a pending sponsorship request for this entity');
+      throw new RacingApplicationError('You already have a pending sponsorship request for this entity');
     }
 
     // Validate offered amount meets minimum price
     const minPrice = pricing.getPrice(dto.tier);
     if (minPrice && dto.offeredAmount < minPrice.amount) {
-      throw new Error(`Offered amount must be at least ${minPrice.format()}`);
+      throw new RacingApplicationError(`Offered amount must be at least ${minPrice.format()}`);
     }
 
     // Create the sponsorship request

packages/racing/application/use-cases/GetLeagueFullConfigUseCase.ts

@@ -3,6 +3,7 @@ import type { ISeasonRepository } from '../../domain/repositories/ISeasonReposit
 import type { ILeagueScoringConfigRepository } from '../../domain/repositories/ILeagueScoringConfigRepository';
 import type { IGameRepository } from '../../domain/repositories/IGameRepository';
 import type { ILeagueFullConfigPresenter, LeagueFullConfigData } from '../presenters/ILeagueFullConfigPresenter';
+import { EntityNotFoundError } from '../errors/RacingApplicationError';
 
 /**
  * Use Case for retrieving a league's full configuration.
@@ -22,7 +23,7 @@ export class GetLeagueFullConfigUseCase {
 
     const league = await this.leagueRepository.findById(leagueId);
     if (!league) {
-      throw new Error(`League ${leagueId} not found`);
+      throw new EntityNotFoundError({ entity: 'league', id: leagueId });
     }
 
     const seasons = await this.seasonRepository.findByLeagueId(leagueId);

packages/racing/application/use-cases/ImportRaceResultsUseCase.ts

@@ -3,6 +3,10 @@ import type { ILeagueRepository } from '../../domain/repositories/ILeagueReposit
 import type { IResultRepository } from '../../domain/repositories/IResultRepository';
 import type { IStandingRepository } from '../../domain/repositories/IStandingRepository';
 import { Result } from '../../domain/entities/Result';
+import {
+  BusinessRuleViolationError,
+  EntityNotFoundError,
+} from '../errors/RacingApplicationError';
 import type {
   IImportRaceResultsPresenter,
   ImportRaceResultsSummaryViewModel,
@@ -37,17 +41,17 @@ export class ImportRaceResultsUseCase {
 
     const race = await this.raceRepository.findById(raceId);
     if (!race) {
-      throw new Error('Race not found');
+      throw new EntityNotFoundError({ entity: 'race', id: raceId });
     }
 
     const league = await this.leagueRepository.findById(race.leagueId);
     if (!league) {
-      throw new Error('League not found');
+      throw new EntityNotFoundError({ entity: 'league', id: race.leagueId });
     }
 
     const existing = await this.resultRepository.existsByRaceId(raceId);
     if (existing) {
-      throw new Error('Results already exist for this race');
+      throw new BusinessRuleViolationError('Results already exist for this race');
     }
 
     const entities = results.map((dto) =>

packages/racing/application/use-cases/JoinLeagueUseCase.ts

@@ -7,6 +7,7 @@ import type {
   MembershipStatus,
 } from '@gridpilot/racing/domain/entities/LeagueMembership';
 import type { JoinLeagueCommandDTO } from '../dto/JoinLeagueCommandDTO';
+import { BusinessRuleViolationError } from '../errors/RacingApplicationError';
 
 export class JoinLeagueUseCase {
   constructor(private readonly membershipRepository: ILeagueMembershipRepository) {}
@@ -23,7 +24,7 @@ export class JoinLeagueUseCase {
 
     const existing = await this.membershipRepository.getMembership(leagueId, driverId);
     if (existing) {
-      throw new Error('Already a member or have a pending request');
+      throw new BusinessRuleViolationError('Already a member or have a pending request');
     }
 
     const membership: LeagueMembership = {

packages/racing/application/use-cases/JoinTeamUseCase.ts

@@ -6,6 +6,10 @@ import type {
   TeamRole,
 } from '../../domain/entities/Team';
 import type { JoinTeamCommandDTO } from '../dto/TeamCommandAndQueryDTO';
+import {
+  BusinessRuleViolationError,
+  EntityNotFoundError,
+} from '../errors/RacingApplicationError';
 
 export class JoinTeamUseCase {
   constructor(
@@ -20,17 +24,17 @@ export class JoinTeamUseCase {
       driverId,
     );
     if (existingActive) {
-      throw new Error('Driver already belongs to a team');
+      throw new BusinessRuleViolationError('Driver already belongs to a team');
     }
 
     const existingMembership = await this.membershipRepository.getMembership(teamId, driverId);
     if (existingMembership) {
-      throw new Error('Already a member or have a pending request');
+      throw new BusinessRuleViolationError('Already a member or have a pending request');
     }
 
     const team = await this.teamRepository.findById(teamId);
     if (!team) {
-      throw new Error('Team not found');
+      throw new EntityNotFoundError({ entity: 'team', id: teamId });
     }
 
     const membership: TeamMembership = {

packages/racing/application/use-cases/RegisterForRaceUseCase.ts

@@ -2,6 +2,10 @@ import type { IRaceRegistrationRepository } from '@gridpilot/racing/domain/repos
 import type { ILeagueMembershipRepository } from '@gridpilot/racing/domain/repositories/ILeagueMembershipRepository';
 import type { RaceRegistration } from '@gridpilot/racing/domain/entities/RaceRegistration';
 import type { RegisterForRaceCommandDTO } from '../dto/RegisterForRaceCommandDTO';
+import {
+  BusinessRuleViolationError,
+  PermissionDeniedError,
+} from '../errors/RacingApplicationError';
 
 export class RegisterForRaceUseCase {
   constructor(
@@ -20,12 +24,12 @@ export class RegisterForRaceUseCase {
 
     const alreadyRegistered = await this.registrationRepository.isRegistered(raceId, driverId);
     if (alreadyRegistered) {
-      throw new Error('Already registered for this race');
+      throw new BusinessRuleViolationError('Already registered for this race');
     }
 
     const membership = await this.membershipRepository.getMembership(leagueId, driverId);
     if (!membership || membership.status !== 'active') {
-      throw new Error('Must be an active league member to register for races');
+      throw new PermissionDeniedError('NOT_ACTIVE_MEMBER', 'Must be an active league member to register for races');
     }
 
     const registration: RaceRegistration = {

packages/racing/application/use-cases/ReviewProtestUseCase.ts

@@ -7,6 +7,10 @@
 import type { IProtestRepository } from '../../domain/repositories/IProtestRepository';
 import type { IRaceRepository } from '../../domain/repositories/IRaceRepository';
 import type { ILeagueMembershipRepository } from '../../domain/repositories/ILeagueMembershipRepository';
+import {
+  EntityNotFoundError,
+  PermissionDeniedError,
+} from '../errors/RacingApplicationError';
 
 export interface ReviewProtestCommand {
   protestId: string;
@@ -26,13 +30,13 @@ export class ReviewProtestUseCase {
     // Load the protest
     const protest = await this.protestRepository.findById(command.protestId);
     if (!protest) {
-      throw new Error('Protest not found');
+      throw new EntityNotFoundError({ entity: 'protest', id: command.protestId });
     }
 
     // Load the race to get league ID
     const race = await this.raceRepository.findById(protest.raceId);
     if (!race) {
-      throw new Error('Race not found');
+      throw new EntityNotFoundError({ entity: 'race', id: protest.raceId });
     }
 
     // Validate steward has authority (owner or admin of the league)
@@ -42,7 +46,10 @@ export class ReviewProtestUseCase {
     );
     
     if (!stewardMembership || (stewardMembership.role !== 'owner' && stewardMembership.role !== 'admin')) {
-      throw new Error('Only league owners and admins can review protests');
+      throw new PermissionDeniedError(
+        'NOT_LEAGUE_ADMIN',
+        'Only league owners and admins can review protests',
+      );
     }
 
     // Apply the decision