website refactor

apps/website/lib/services/leaderboards/DriverRankingsService.ts

@@ -0,0 +1,59 @@
+import { DriversApiClient } from '@/lib/api/drivers/DriversApiClient';
+import { Result } from '@/lib/contracts/Result';
+import { Service, DomainError } from '@/lib/contracts/services/Service';
+import { ConsoleErrorReporter } from '@/lib/infrastructure/logging/ConsoleErrorReporter';
+import { ConsoleLogger } from '@/lib/infrastructure/logging/ConsoleLogger';
+import type { DriverLeaderboardItemDTO } from '@/lib/types/generated/DriverLeaderboardItemDTO';
+import { getWebsiteApiBaseUrl } from '@/lib/config/apiBaseUrl';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+export interface DriverRankingsData {
+  drivers: DriverLeaderboardItemDTO[];
+}
+
+export class DriverRankingsService implements Service {
+  async getDriverRankings(): Promise<Result<DriverRankingsData, DomainError>> {
+    try {
+      const baseUrl = getWebsiteApiBaseUrl();
+      const errorReporter = new ConsoleErrorReporter();
+      const logger = new ConsoleLogger();
+      
+      const apiClient = new DriversApiClient(baseUrl, errorReporter, logger);
+      const result = await apiClient.getLeaderboard();
+      
+      if (!result || !result.drivers) {
+        return Result.err({ type: 'notFound', message: 'No driver rankings available' });
+      }
+
+      const data: DriverRankingsData = {
+        drivers: result.drivers,
+      };
+      
+      return Result.ok(data);
+    } catch (error) {
+      // Convert ApiError to DomainError
+      if (error instanceof ApiError) {
+        switch (error.type) {
+          case 'NOT_FOUND':
+            return Result.err({ type: 'notFound', message: error.message });
+          case 'AUTH_ERROR':
+            return Result.err({ type: 'unauthorized', message: error.message });
+          case 'SERVER_ERROR':
+            return Result.err({ type: 'serverError', message: error.message });
+          case 'NETWORK_ERROR':
+          case 'TIMEOUT_ERROR':
+            return Result.err({ type: 'networkError', message: error.message });
+          default:
+            return Result.err({ type: 'unknown', message: error.message });
+        }
+      }
+      
+      // Handle non-ApiError cases
+      if (error instanceof Error) {
+        return Result.err({ type: 'unknown', message: error.message });
+      }
+      
+      return Result.err({ type: 'unknown', message: 'Driver rankings fetch failed' });
+    }
+  }
+}

apps/website/lib/services/leaderboards/LeaderboardsService.ts

@@ -0,0 +1,77 @@
+import { DriversApiClient } from '@/lib/api/drivers/DriversApiClient';
+import { TeamsApiClient } from '@/lib/api/teams/TeamsApiClient';
+import { Result } from '@/lib/contracts/Result';
+import { Service, DomainError } from '@/lib/contracts/services/Service';
+import { ConsoleErrorReporter } from '@/lib/infrastructure/logging/ConsoleErrorReporter';
+import { ConsoleLogger } from '@/lib/infrastructure/logging/ConsoleLogger';
+import type { DriverLeaderboardItemDTO } from '@/lib/types/generated/DriverLeaderboardItemDTO';
+import type { TeamListItemDTO } from '@/lib/types/generated/TeamListItemDTO';
+import { getWebsiteApiBaseUrl } from '@/lib/config/apiBaseUrl';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+export interface LeaderboardsData {
+  drivers: { drivers: DriverLeaderboardItemDTO[] };
+  teams: { teams: TeamListItemDTO[] };
+}
+
+export class LeaderboardsService implements Service {
+  async getLeaderboards(): Promise<Result<LeaderboardsData, DomainError>> {
+    try {
+      const baseUrl = getWebsiteApiBaseUrl();
+      const errorReporter = new ConsoleErrorReporter();
+      const logger = new ConsoleLogger();
+      
+      const driversApiClient = new DriversApiClient(baseUrl, errorReporter, logger);
+      const teamsApiClient = new TeamsApiClient(baseUrl, errorReporter, logger);
+      
+      const [driverResult, teamResult] = await Promise.all([
+        driversApiClient.getLeaderboard(),
+        teamsApiClient.getAll(),
+      ]);
+      
+      if (!driverResult && !teamResult) {
+        return Result.err({ type: 'notFound', message: 'No leaderboard data available' });
+      }
+
+      // Check if team ranking is needed but not provided by API
+      // TeamListItemDTO does not have a rank field, so we cannot provide ranked team data
+      if (teamResult && teamResult.teams.length > 0) {
+        const hasRankField = teamResult.teams.some(team => 'rank' in team);
+        if (!hasRankField) {
+          return Result.err({ type: 'serverError', message: 'Team ranking not implemented' });
+        }
+      }
+
+      const data: LeaderboardsData = {
+        drivers: driverResult || { drivers: [] },
+        teams: teamResult || { teams: [] },
+      };
+      
+      return Result.ok(data);
+    } catch (error) {
+      // Convert ApiError to DomainError
+      if (error instanceof ApiError) {
+        switch (error.type) {
+          case 'NOT_FOUND':
+            return Result.err({ type: 'notFound', message: error.message });
+          case 'AUTH_ERROR':
+            return Result.err({ type: 'unauthorized', message: error.message });
+          case 'SERVER_ERROR':
+            return Result.err({ type: 'serverError', message: error.message });
+          case 'NETWORK_ERROR':
+          case 'TIMEOUT_ERROR':
+            return Result.err({ type: 'networkError', message: error.message });
+          default:
+            return Result.err({ type: 'unknown', message: error.message });
+        }
+      }
+      
+      // Handle non-ApiError cases
+      if (error instanceof Error) {
+        return Result.err({ type: 'unknown', message: error.message });
+      }
+      
+      return Result.err({ type: 'unknown', message: 'Leaderboards fetch failed' });
+    }
+  }
+}