website refactor

apps/website/lib/services/error/ErrorAnalyticsService.ts

@@ -29,6 +29,10 @@ export interface ErrorStats {
   };
 }
 
+export function getErrorAnalyticsStats(): ErrorStats {
+  return ErrorAnalyticsService.getErrorAnalyticsStats();
+}
+
 export class ErrorAnalyticsService implements Service {
   static getErrorAnalyticsStats(): ErrorStats {
     const globalHandler = getGlobalErrorHandler();

apps/website/lib/services/leagues/ProfileLeaguesService.ts

@@ -1,4 +1,6 @@
-import { ApiClient } from '@/lib/api';
+import { LeaguesApiClient } from '@/lib/api/leagues/LeaguesApiClient';
+import { ConsoleLogger } from '@/lib/infrastructure/logging/ConsoleLogger';
+import { ConsoleErrorReporter } from '@/lib/infrastructure/logging/ConsoleErrorReporter';
 import { getWebsiteApiBaseUrl } from '@/lib/config/apiBaseUrl';
 import { Result } from '@/lib/contracts/Result';
 import { Service, type DomainError } from '@/lib/contracts/services/Service';
@@ -28,9 +30,11 @@ export class ProfileLeaguesService implements Service {
   async getProfileLeagues(driverId: string): Promise<Result<ProfileLeaguesPageDto, DomainError>> {
     try {
       const baseUrl = getWebsiteApiBaseUrl();
-      const apiClient = new ApiClient(baseUrl);
+      const logger = new ConsoleLogger();
+      const errorReporter = new ConsoleErrorReporter();
+      const leaguesApiClient = new LeaguesApiClient(baseUrl, errorReporter, logger);
       
-      const leaguesDto = await apiClient.leagues.getAllWithCapacity();
+      const leaguesDto = await leaguesApiClient.getAllWithCapacity();
       
       if (!leaguesDto?.leagues) {
         return Result.err({ type: 'notFound', message: 'Leagues not found' });
@@ -40,7 +44,7 @@ export class ProfileLeaguesService implements Service {
       const leagueMemberships = await Promise.all(
         leaguesDto.leagues.map(async (league) => {
           try {
-            const membershipsDto = await apiClient.leagues.getMemberships(league.id);
+            const membershipsDto = await leaguesApiClient.getMemberships(league.id);
             
             let memberships: MembershipDTO[] = [];
             if (membershipsDto && typeof membershipsDto === 'object') {

apps/website/lib/services/races/RaceService.ts

@@ -41,6 +41,15 @@ export class RaceService implements Service {
     }
   }
 
+  async getAllRacesPageData(): Promise<Result<any, DomainError>> {
+    try {
+      const data = await this.apiClient.getPageData();
+      return Result.ok(data);
+    } catch (error: unknown) {
+      return Result.err(this.mapError(error, 'Failed to fetch all races page data'));
+    }
+  }
+
   async findByLeagueId(leagueId: string): Promise<Result<unknown[], DomainError>> {
     try {
       const result = await this.apiClient.getPageData(leagueId);

apps/website/lib/services/teams/TeamService.ts

@@ -1,5 +1,12 @@
 import { TeamsApiClient } from '@/lib/api/teams/TeamsApiClient';
 import type { TeamListItemDTO } from '@/lib/types/generated/TeamListItemDTO';
+import type { CreateTeamInputDTO } from '@/lib/types/generated/CreateTeamInputDTO';
+import type { CreateTeamOutputDTO } from '@/lib/types/generated/CreateTeamOutputDTO';
+import type { UpdateTeamInputDTO } from '@/lib/types/generated/UpdateTeamInputDTO';
+import type { UpdateTeamOutputDTO } from '@/lib/types/generated/UpdateTeamOutputDTO';
+import type { GetDriverTeamOutputDTO } from '@/lib/types/generated/GetDriverTeamOutputDTO';
+import type { GetTeamMembershipOutputDTO } from '@/lib/types/generated/GetTeamMembershipOutputDTO';
+import type { GetTeamJoinRequestsOutputDTO } from '@/lib/types/generated/GetTeamJoinRequestsOutputDTO';
 import { TeamMemberViewModel } from '@/lib/view-models/TeamMemberViewModel';
 import { Result } from '@/lib/contracts/Result';
 import { DomainError, Service } from '@/lib/contracts/services/Service';
@@ -37,7 +44,7 @@ export class TeamService implements Service {
     }
   }
 
-  async getTeamDetails(teamId: string, _: string): Promise<Result<unknown, DomainError>> {
+  async getTeamDetails(teamId: string, _: string): Promise<Result<any, DomainError>> {
     try {
       const result = await this.apiClient.getDetails(teamId);
       if (!result) {
@@ -58,23 +65,48 @@ export class TeamService implements Service {
     }
   }
 
-  async getTeamJoinRequests(_: string): Promise<Result<unknown, DomainError>> {
-    return Result.err({ type: 'notImplemented', message: 'getTeamJoinRequests' });
+  async getTeamJoinRequests(teamId: string): Promise<Result<GetTeamJoinRequestsOutputDTO, DomainError>> {
+    try {
+      const result = await this.apiClient.getJoinRequests(teamId);
+      return Result.ok(result);
+    } catch (error: unknown) {
+      return Result.err({ type: 'unknown', message: (error as Error).message || 'Failed to fetch team join requests' });
+    }
   }
 
-  async createTeam(__: unknown): Promise<Result<unknown, DomainError>> {
-    return Result.err({ type: 'notImplemented', message: 'createTeam' });
+  async createTeam(input: CreateTeamInputDTO): Promise<Result<CreateTeamOutputDTO, DomainError>> {
+    try {
+      const result = await this.apiClient.create(input);
+      return Result.ok(result);
+    } catch (error: unknown) {
+      return Result.err({ type: 'unknown', message: (error as Error).message || 'Failed to create team' });
+    }
   }
 
-  async updateTeam(_: string, __: unknown): Promise<Result<unknown, DomainError>> {
-    return Result.err({ type: 'notImplemented', message: 'updateTeam' });
+  async updateTeam(teamId: string, input: UpdateTeamInputDTO): Promise<Result<UpdateTeamOutputDTO, DomainError>> {
+    try {
+      const result = await this.apiClient.update(teamId, input);
+      return Result.ok(result);
+    } catch (error: unknown) {
+      return Result.err({ type: 'unknown', message: (error as Error).message || 'Failed to update team' });
+    }
   }
 
-  async getDriverTeam(_: string): Promise<Result<unknown, DomainError>> {
-    return Result.err({ type: 'notImplemented', message: 'getDriverTeam' });
+  async getDriverTeam(driverId: string): Promise<Result<GetDriverTeamOutputDTO | null, DomainError>> {
+    try {
+      const result = await this.apiClient.getDriverTeam(driverId);
+      return Result.ok(result);
+    } catch (error: unknown) {
+      return Result.err({ type: 'unknown', message: (error as Error).message || 'Failed to fetch driver team' });
+    }
   }
 
-  async getMembership(_: string, __: string): Promise<Result<unknown, DomainError>> {
-    return Result.err({ type: 'notImplemented', message: 'getMembership' });
+  async getMembership(teamId: string, driverId: string): Promise<Result<GetTeamMembershipOutputDTO | null, DomainError>> {
+    try {
+      const result = await this.apiClient.getMembership(teamId, driverId);
+      return Result.ok(result);
+    } catch (error: unknown) {
+      return Result.err({ type: 'unknown', message: (error as Error).message || 'Failed to fetch team membership' });
+    }
   }
 }