website refactor

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

@@ -0,0 +1,84 @@
+import { getGlobalErrorHandler } from '@/lib/infrastructure/GlobalErrorHandler';
+import { getGlobalApiLogger } from '@/lib/infrastructure/ApiRequestLogger';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+export interface ErrorStats {
+  totalErrors: number;
+  errorsByType: Record<string, number>;
+  errorsByTime: Array<{ time: string; count: number }>;
+  recentErrors: Array<{
+    timestamp: string;
+    message: string;
+    type: string;
+    context?: unknown;
+  }>;
+  apiStats: {
+    totalRequests: number;
+    successful: number;
+    failed: number;
+    averageDuration: number;
+    slowestRequests: Array<{ url: string; duration: number }>;
+  };
+  environment: {
+    mode: string;
+    version?: string;
+    buildTime?: string;
+  };
+}
+
+export function getErrorAnalyticsStats(): ErrorStats {
+  const globalHandler = getGlobalErrorHandler();
+  const apiLogger = getGlobalApiLogger();
+
+  const errorHistory = globalHandler.getErrorHistory();
+  const errorStats = globalHandler.getStats();
+  const apiStats = apiLogger.getStats();
+
+  // Group errors by time (last 10 minutes)
+  const timeGroups = new Map<string, number>();
+  const now = Date.now();
+  const tenMinutesAgo = now - (10 * 60 * 1000);
+
+  errorHistory.forEach(entry => {
+    const entryTime = new Date(entry.timestamp).getTime();
+    if (entryTime >= tenMinutesAgo) {
+      const timeKey = new Date(entry.timestamp).toLocaleTimeString();
+      timeGroups.set(timeKey, (timeGroups.get(timeKey) || 0) + 1);
+    }
+  });
+
+  const errorsByTime = Array.from(timeGroups.entries())
+    .map(([time, count]) => ({ time, count }))
+    .sort((a, b) => a.time.localeCompare(b.time));
+
+  const recentErrors = errorHistory.slice(-10).reverse().map(entry => ({
+    timestamp: entry.timestamp,
+    message: entry.error.message,
+    type: entry.error instanceof ApiError ? entry.error.type : entry.error.name || 'Error',
+    context: entry.context,
+  }));
+
+  const slowestRequests = apiLogger.getSlowestRequests(5).map(log => ({
+    url: log.url,
+    duration: log.response?.duration || 0,
+  }));
+
+  return {
+    totalErrors: errorStats.total,
+    errorsByType: errorStats.byType,
+    errorsByTime,
+    recentErrors,
+    apiStats: {
+      totalRequests: apiStats.total,
+      successful: apiStats.successful,
+      failed: apiStats.failed,
+      averageDuration: apiStats.averageDuration,
+      slowestRequests,
+    },
+    environment: {
+      mode: process.env.NODE_ENV || 'unknown',
+      version: process.env.NEXT_PUBLIC_APP_VERSION,
+      buildTime: process.env.NEXT_PUBLIC_BUILD_TIME,
+    },
+  };
+}

apps/website/lib/services/league/LeagueActivityService.ts

@@ -0,0 +1,41 @@
+import type { LeagueActivity } from '@/components/leagues/LeagueActivityFeed';
+
+export function processLeagueActivities(raceList: any[], limit: number): LeagueActivity[] {
+  const activities: LeagueActivity[] = [];
+  
+  const completedRaces = raceList
+    .filter((r) => r.status === 'completed')
+    .sort((a, b) => new Date(b.scheduledAt).getTime() - new Date(a.scheduledAt).getTime())
+    .slice(0, 5);
+
+  const upcomingRaces = raceList
+    .filter((r) => r.status === 'scheduled')
+    .sort((a, b) => new Date(b.scheduledAt).getTime() - new Date(a.scheduledAt).getTime())
+    .slice(0, 3);
+
+  for (const race of completedRaces) {
+    activities.push({
+      type: 'race_completed',
+      raceId: race.id,
+      raceName: `${race.track} - ${race.car}`,
+      timestamp: new Date(race.scheduledAt),
+    });
+  }
+
+  for (const race of upcomingRaces) {
+    activities.push({
+      type: 'race_scheduled',
+      raceId: race.id,
+      raceName: `${race.track} - ${race.car}`,
+      timestamp: new Date(new Date(race.scheduledAt).getTime() - 7 * 24 * 60 * 60 * 1000), // Simulate schedule announcement
+    });
+  }
+
+  // Sort all activities by timestamp
+  activities.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+  if (activities.length > limit) {
+    activities.splice(limit);
+  }
+
+  return activities;
+}

apps/website/lib/utilities/roster-utils.ts

@@ -0,0 +1,48 @@
+import type { TeamMemberRole } from '@/components/teams/TeamRoster';
+
+interface TeamMember {
+  driver: {
+    id: string;
+    name: string;
+    country: string;
+  };
+  role: TeamMemberRole;
+  joinedAt: string;
+  rating: number | null;
+  overallRank: number | null;
+}
+
+export function sortMembers(members: TeamMember[], sortBy: string) {
+  function getRoleOrder(role: TeamMemberRole): number {
+    switch (role) {
+      case 'owner':
+        return 0;
+      case 'manager':
+        return 1;
+      case 'member':
+        return 2;
+      default:
+        return 3;
+    }
+  }
+
+  const list = [...members];
+  list.sort((a, b) => {
+    switch (sortBy) {
+      case 'rating': {
+        const ratingA = a.rating ?? 0;
+        const ratingB = b.rating ?? 0;
+        return ratingB - ratingA;
+      }
+      case 'role': {
+        return getRoleOrder(a.role) - getRoleOrder(b.role);
+      }
+      case 'name': {
+        return a.driver.name.localeCompare(b.driver.name);
+      }
+      default:
+        return 0;
+    }
+  });
+  return list;
+}