wip

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

@@ -0,0 +1,141 @@
+import { v4 as uuidv4 } from 'uuid';
+import { League } from '../../domain/entities/League';
+import type { ILeagueRepository } from '../../domain/repositories/ILeagueRepository';
+import type { ISeasonRepository } from '../../domain/repositories/ISeasonRepository';
+import type { ILeagueScoringConfigRepository } from '../../domain/repositories/ILeagueScoringConfigRepository';
+import type { LeagueScoringConfig } from '../../domain/entities/LeagueScoringConfig';
+import type {
+  LeagueScoringPresetProvider,
+  LeagueScoringPresetDTO,
+} from '../ports/LeagueScoringPresetProvider';
+
+export interface CreateLeagueWithSeasonAndScoringCommand {
+  name: string;
+  description?: string;
+  visibility: 'public' | 'private';
+  ownerId: string;
+  gameId: string;
+  maxDrivers?: number;
+  maxTeams?: number;
+  enableDriverChampionship: boolean;
+  enableTeamChampionship: boolean;
+  enableNationsChampionship: boolean;
+  enableTrophyChampionship: boolean;
+  scoringPresetId?: string;
+}
+
+export interface CreateLeagueWithSeasonAndScoringResultDTO {
+  leagueId: string;
+  seasonId: string;
+  scoringPresetId?: string;
+  scoringPresetName?: string;
+}
+
+export class CreateLeagueWithSeasonAndScoringUseCase {
+  constructor(
+    private readonly leagueRepository: ILeagueRepository,
+    private readonly seasonRepository: ISeasonRepository,
+    private readonly leagueScoringConfigRepository: ILeagueScoringConfigRepository,
+    private readonly presetProvider: LeagueScoringPresetProvider,
+  ) {}
+
+  async execute(
+    command: CreateLeagueWithSeasonAndScoringCommand,
+  ): Promise<CreateLeagueWithSeasonAndScoringResultDTO> {
+    this.validate(command);
+
+    const leagueId = uuidv4();
+
+    const league = League.create({
+      id: leagueId,
+      name: command.name,
+      description: command.description ?? '',
+      ownerId: command.ownerId,
+      settings: {
+        pointsSystem: (command.scoringPresetId as any) ?? 'custom',
+        maxDrivers: command.maxDrivers,
+      },
+    });
+
+    await this.leagueRepository.create(league);
+
+    const seasonId = uuidv4();
+    const season = {
+      id: seasonId,
+      leagueId: league.id,
+      gameId: command.gameId,
+      name: `${command.name} Season 1`,
+      year: new Date().getFullYear(),
+      order: 1,
+      status: 'active' as const,
+      startDate: new Date(),
+      endDate: new Date(),
+    };
+
+    // Season is a domain entity; use the repository's create, but shape matches Season.create expectations.
+    // To keep this use case independent, we rely on repository to persist the plain object.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    await this.seasonRepository.create(season as any);
+
+    const presetId = command.scoringPresetId ?? 'club-default';
+    const preset: LeagueScoringPresetDTO | undefined =
+      this.presetProvider.getPresetById(presetId);
+
+    if (!preset) {
+      throw new Error(`Unknown scoring preset: ${presetId}`);
+    }
+
+    const scoringConfig: LeagueScoringConfig = {
+      id: uuidv4(),
+      seasonId,
+      scoringPresetId: preset.id,
+      championships: [],
+    };
+
+    // For the initial alpha slice, we keep using the preset's config shape from the in-memory registry.
+    // The preset registry is responsible for building the full LeagueScoringConfig; we only attach the preset id here.
+    const fullConfigFactory = (await import(
+      '../../infrastructure/repositories/InMemoryScoringRepositories'
+    )) as typeof import('../../infrastructure/repositories/InMemoryScoringRepositories');
+
+    const presetFromInfra = fullConfigFactory.getLeagueScoringPresetById(
+      preset.id,
+    );
+    if (!presetFromInfra) {
+      throw new Error(`Preset registry missing preset: ${preset.id}`);
+    }
+
+    const infraConfig = presetFromInfra.createConfig({ seasonId });
+    const finalConfig: LeagueScoringConfig = {
+      ...infraConfig,
+      scoringPresetId: preset.id,
+    };
+
+    await this.leagueScoringConfigRepository.save(finalConfig);
+
+    return {
+      leagueId: league.id,
+      seasonId,
+      scoringPresetId: preset.id,
+      scoringPresetName: preset.name,
+    };
+  }
+
+  private validate(command: CreateLeagueWithSeasonAndScoringCommand): void {
+    if (!command.name || command.name.trim().length === 0) {
+      throw new Error('League name is required');
+    }
+    if (!command.ownerId || command.ownerId.trim().length === 0) {
+      throw new Error('League ownerId is required');
+    }
+    if (!command.gameId || command.gameId.trim().length === 0) {
+      throw new Error('gameId is required');
+    }
+    if (!command.visibility) {
+      throw new Error('visibility is required');
+    }
+    if (command.maxDrivers !== undefined && command.maxDrivers <= 0) {
+      throw new Error('maxDrivers must be greater than 0 when provided');
+    }
+  }
+}