wip

packages/racing/application/dto/RaceDTO.ts

@@ -3,7 +3,12 @@ export type RaceDTO = {
   leagueId: string;
   scheduledAt: string;
   track: string;
+  trackId?: string;
   car: string;
+  carId?: string;
   sessionType: 'practice' | 'qualifying' | 'race';
-  status: 'scheduled' | 'completed' | 'cancelled';
+  status: 'scheduled' | 'running' | 'completed' | 'cancelled';
+  strengthOfField?: number;
+  registeredCount?: number;
+  maxParticipants?: number;
 };

packages/racing/application/index.ts

@@ -24,6 +24,11 @@ export * from './use-cases/RecalculateChampionshipStandingsUseCase';
 export * from './use-cases/CreateLeagueWithSeasonAndScoringUseCase';
 export * from './use-cases/GetLeagueFullConfigQuery';
 export * from './use-cases/PreviewLeagueScheduleQuery';
+export * from './use-cases/GetRaceWithSOFQuery';
+export * from './use-cases/GetLeagueStatsQuery';
+
+// Export ports
+export * from './ports/DriverRatingProvider';
 
  // Re-export domain types for legacy callers (type-only)
  export type {

packages/racing/application/mappers/EntityMappers.ts

@@ -76,9 +76,14 @@ export class EntityMappers {
       leagueId: race.leagueId,
       scheduledAt: race.scheduledAt.toISOString(),
       track: race.track,
+      trackId: race.trackId,
       car: race.car,
+      carId: race.carId,
       sessionType: race.sessionType,
       status: race.status,
+      strengthOfField: race.strengthOfField,
+      registeredCount: race.registeredCount,
+      maxParticipants: race.maxParticipants,
     };
   }
 
@@ -88,9 +93,14 @@ export class EntityMappers {
       leagueId: race.leagueId,
       scheduledAt: race.scheduledAt.toISOString(),
       track: race.track,
+      trackId: race.trackId,
       car: race.car,
+      carId: race.carId,
       sessionType: race.sessionType,
       status: race.status,
+      strengthOfField: race.strengthOfField,
+      registeredCount: race.registeredCount,
+      maxParticipants: race.maxParticipants,
     }));
   }
 

packages/racing/application/ports/DriverRatingProvider.ts

@@ -0,0 +1,20 @@
+/**
+ * Application Port: DriverRatingProvider
+ * 
+ * Port for looking up driver ratings.
+ * Implemented by infrastructure adapters that connect to rating systems.
+ */
+
+export interface DriverRatingProvider {
+  /**
+   * Get the rating for a single driver
+   * Returns null if driver has no rating
+   */
+  getRating(driverId: string): number | null;
+  
+  /**
+   * Get ratings for multiple drivers
+   * Returns a map of driverId -> rating
+   */
+  getRatings(driverIds: string[]): Map<string, number>;
+}

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

@@ -114,7 +114,7 @@ export class GetLeagueScoringConfigQuery {
 
     for (const [sessionType, table] of Object.entries(tables)) {
       for (let pos = 1; pos <= maxPositions; pos++) {
-        const points = table.getPoints(pos);
+        const points = table.getPointsForPosition(pos);
         if (points && points !== 0) {
           preview.push({
             sessionType,

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

@@ -0,0 +1,99 @@
+/**
+ * Application Query: GetLeagueStatsQuery
+ * 
+ * Returns league statistics including average SOF across completed races.
+ */
+
+import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
+import type { IRaceRepository } from '../../domain/repositories/IRaceRepository';
+import type { IResultRepository } from '../../domain/repositories/IResultRepository';
+import type { DriverRatingProvider } from '../ports/DriverRatingProvider';
+import {
+  AverageStrengthOfFieldCalculator,
+  type StrengthOfFieldCalculator,
+} from '../../domain/services/StrengthOfFieldCalculator';
+
+export interface GetLeagueStatsQueryParams {
+  leagueId: string;
+}
+
+export interface LeagueStatsDTO {
+  leagueId: string;
+  totalRaces: number;
+  completedRaces: number;
+  scheduledRaces: number;
+  averageSOF: number | null;
+  highestSOF: number | null;
+  lowestSOF: number | null;
+}
+
+export class GetLeagueStatsQuery {
+  private readonly sofCalculator: StrengthOfFieldCalculator;
+
+  constructor(
+    private readonly leagueRepository: ILeagueRepository,
+    private readonly raceRepository: IRaceRepository,
+    private readonly resultRepository: IResultRepository,
+    private readonly driverRatingProvider: DriverRatingProvider,
+    sofCalculator?: StrengthOfFieldCalculator,
+  ) {
+    this.sofCalculator = sofCalculator ?? new AverageStrengthOfFieldCalculator();
+  }
+
+  async execute(params: GetLeagueStatsQueryParams): Promise<LeagueStatsDTO | null> {
+    const { leagueId } = params;
+
+    const league = await this.leagueRepository.findById(leagueId);
+    if (!league) {
+      return null;
+    }
+
+    const races = await this.raceRepository.findByLeagueId(leagueId);
+    const completedRaces = races.filter(r => r.status === 'completed');
+    const scheduledRaces = races.filter(r => r.status === 'scheduled');
+
+    // Calculate SOF for each completed race
+    const sofValues: number[] = [];
+
+    for (const race of completedRaces) {
+      // Use stored SOF if available
+      if (race.strengthOfField) {
+        sofValues.push(race.strengthOfField);
+        continue;
+      }
+
+      // Otherwise calculate from results
+      const results = await this.resultRepository.findByRaceId(race.id);
+      if (results.length === 0) continue;
+
+      const driverIds = results.map(r => r.driverId);
+      const ratings = this.driverRatingProvider.getRatings(driverIds);
+      const driverRatings = driverIds
+        .filter(id => ratings.has(id))
+        .map(id => ({ driverId: id, rating: ratings.get(id)! }));
+
+      const sof = this.sofCalculator.calculate(driverRatings);
+      if (sof !== null) {
+        sofValues.push(sof);
+      }
+    }
+
+    // Calculate aggregate stats
+    const averageSOF = sofValues.length > 0
+      ? Math.round(sofValues.reduce((a, b) => a + b, 0) / sofValues.length)
+      : null;
+    
+    const highestSOF = sofValues.length > 0 ? Math.max(...sofValues) : null;
+    const lowestSOF = sofValues.length > 0 ? Math.min(...sofValues) : null;
+
+    return {
+      leagueId,
+      totalRaces: races.length,
+      completedRaces: completedRaces.length,
+      scheduledRaces: scheduledRaces.length,
+      averageSOF,
+      highestSOF,
+      lowestSOF,
+    };
+  }
+}

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

@@ -0,0 +1,88 @@
+/**
+ * Application Query: GetRaceWithSOFQuery
+ * 
+ * Returns race details enriched with calculated Strength of Field (SOF).
+ * SOF is calculated from participant ratings if not already stored on the race.
+ */
+
+import type { IRaceRepository } from '../../domain/repositories/IRaceRepository';
+import type { IRaceRegistrationRepository } from '../../domain/repositories/IRaceRegistrationRepository';
+import type { IResultRepository } from '../../domain/repositories/IResultRepository';
+import type { DriverRatingProvider } from '../ports/DriverRatingProvider';
+import {
+  AverageStrengthOfFieldCalculator,
+  type StrengthOfFieldCalculator,
+} from '../../domain/services/StrengthOfFieldCalculator';
+import type { RaceDTO } from '../dto/RaceDTO';
+
+export interface GetRaceWithSOFQueryParams {
+  raceId: string;
+}
+
+export interface RaceWithSOFDTO extends Omit<RaceDTO, 'strengthOfField'> {
+  strengthOfField: number | null;
+  participantCount: number;
+}
+
+export class GetRaceWithSOFQuery {
+  private readonly sofCalculator: StrengthOfFieldCalculator;
+
+  constructor(
+    private readonly raceRepository: IRaceRepository,
+    private readonly registrationRepository: IRaceRegistrationRepository,
+    private readonly resultRepository: IResultRepository,
+    private readonly driverRatingProvider: DriverRatingProvider,
+    sofCalculator?: StrengthOfFieldCalculator,
+  ) {
+    this.sofCalculator = sofCalculator ?? new AverageStrengthOfFieldCalculator();
+  }
+
+  async execute(params: GetRaceWithSOFQueryParams): Promise<RaceWithSOFDTO | null> {
+    const { raceId } = params;
+
+    const race = await this.raceRepository.findById(raceId);
+    if (!race) {
+      return null;
+    }
+
+    // Get participant IDs based on race status
+    let participantIds: string[] = [];
+    
+    if (race.status === 'completed') {
+      // For completed races, use results
+      const results = await this.resultRepository.findByRaceId(raceId);
+      participantIds = results.map(r => r.driverId);
+    } else {
+      // For upcoming/running races, use registrations
+      participantIds = await this.registrationRepository.getRegisteredDrivers(raceId);
+    }
+
+    // Use stored SOF if available, otherwise calculate
+    let strengthOfField = race.strengthOfField ?? null;
+    
+    if (strengthOfField === null && participantIds.length > 0) {
+      const ratings = this.driverRatingProvider.getRatings(participantIds);
+      const driverRatings = participantIds
+        .filter(id => ratings.has(id))
+        .map(id => ({ driverId: id, rating: ratings.get(id)! }));
+      
+      strengthOfField = this.sofCalculator.calculate(driverRatings);
+    }
+
+    return {
+      id: race.id,
+      leagueId: race.leagueId,
+      scheduledAt: race.scheduledAt.toISOString(),
+      track: race.track,
+      trackId: race.trackId,
+      car: race.car,
+      carId: race.carId,
+      sessionType: race.sessionType,
+      status: race.status,
+      strengthOfField,
+      registeredCount: race.registeredCount ?? participantIds.length,
+      maxParticipants: race.maxParticipants,
+      participantCount: participantIds.length,
+    };
+  }
+}