di usage in website

apps/website/hooks/auth/index.ts

@@ -0,0 +1,6 @@
+export { useCurrentSession } from './useCurrentSession';
+export { useLogin } from './useLogin';
+export { useLogout } from './useLogout';
+export { useSignup } from './useSignup';
+export { useForgotPassword } from './useForgotPassword';
+export { useResetPassword } from './useResetPassword';

apps/website/hooks/auth/useCurrentSession.ts

@@ -0,0 +1,21 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { SESSION_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+import { ApiError } from '@/lib/api/base/ApiError';
+import { SessionViewModel } from '@/lib/view-models/SessionViewModel';
+
+export function useCurrentSession(
+  options?: Omit<UseQueryOptions<SessionViewModel | null, ApiError>, 'queryKey' | 'queryFn'> & { initialData?: SessionViewModel | null }
+) {
+  const sessionService = useInject(SESSION_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['currentSession'],
+    queryFn: () => sessionService.getSession(),
+    initialData: options?.initialData,
+    ...options,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/auth/useForgotPassword.ts

@@ -0,0 +1,16 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { AUTH_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+import type { ForgotPasswordDTO } from '@/lib/types/generated/ForgotPasswordDTO';
+
+export function useForgotPassword(
+  options?: Omit<UseMutationOptions<{ message: string; magicLink?: string }, ApiError, ForgotPasswordDTO>, 'mutationFn'>
+) {
+  const authService = useInject(AUTH_SERVICE_TOKEN);
+
+  return useMutation<{ message: string; magicLink?: string }, ApiError, ForgotPasswordDTO>({
+    mutationFn: (params) => authService.forgotPassword(params),
+    ...options,
+  });
+}

apps/website/hooks/auth/useLogin.ts

@@ -0,0 +1,17 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { AUTH_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+import { SessionViewModel } from '@/lib/view-models/SessionViewModel';
+import type { LoginParamsDTO } from '@/lib/types/generated/LoginParamsDTO';
+
+export function useLogin(
+  options?: Omit<UseMutationOptions<SessionViewModel, ApiError, LoginParamsDTO>, 'mutationFn'>
+) {
+  const authService = useInject(AUTH_SERVICE_TOKEN);
+
+  return useMutation<SessionViewModel, ApiError, LoginParamsDTO>({
+    mutationFn: (params) => authService.login(params),
+    ...options,
+  });
+}

apps/website/hooks/auth/useLogout.ts

@@ -0,0 +1,15 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { AUTH_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+export function useLogout(
+  options?: Omit<UseMutationOptions<void, ApiError, void>, 'mutationFn'>
+) {
+  const authService = useInject(AUTH_SERVICE_TOKEN);
+
+  return useMutation<void, ApiError, void>({
+    mutationFn: () => authService.logout(),
+    ...options,
+  });
+}

apps/website/hooks/auth/useResetPassword.ts

@@ -0,0 +1,16 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { AUTH_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+import type { ResetPasswordDTO } from '@/lib/types/generated/ResetPasswordDTO';
+
+export function useResetPassword(
+  options?: Omit<UseMutationOptions<{ message: string }, ApiError, ResetPasswordDTO>, 'mutationFn'>
+) {
+  const authService = useInject(AUTH_SERVICE_TOKEN);
+
+  return useMutation<{ message: string }, ApiError, ResetPasswordDTO>({
+    mutationFn: (params) => authService.resetPassword(params),
+    ...options,
+  });
+}

apps/website/hooks/auth/useSignup.ts

@@ -0,0 +1,17 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { AUTH_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+import { SessionViewModel } from '@/lib/view-models/SessionViewModel';
+import type { SignupParamsDTO } from '@/lib/types/generated/SignupParamsDTO';
+
+export function useSignup(
+  options?: Omit<UseMutationOptions<SessionViewModel, ApiError, SignupParamsDTO>, 'mutationFn'>
+) {
+  const authService = useInject(AUTH_SERVICE_TOKEN);
+
+  return useMutation<SessionViewModel, ApiError, SignupParamsDTO>({
+    mutationFn: (params) => authService.signup(params),
+    ...options,
+  });
+}

apps/website/hooks/dashboard/useDashboardOverview.ts

@@ -0,0 +1,20 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { DASHBOARD_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+import { ApiError } from '@/lib/api/base/ApiError';
+import { DashboardOverviewViewModel } from '@/lib/view-models/DashboardOverviewViewModel';
+
+export function useDashboardOverview(
+  options?: Omit<UseQueryOptions<DashboardOverviewViewModel, ApiError>, 'queryKey' | 'queryFn'>
+) {
+  const dashboardService = useInject(DASHBOARD_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['dashboardOverview'],
+    queryFn: () => dashboardService.getDashboardOverview(),
+    ...options,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/driver/index.ts

@@ -0,0 +1,6 @@
+export { useCurrentDriver } from './useCurrentDriver';
+export { useDriverLeaderboard } from './useDriverLeaderboard';
+export { useDriverProfile } from './useDriverProfile';
+export { useUpdateDriverProfile } from './useUpdateDriverProfile';
+export { useCreateDriver } from './useCreateDriver';
+export { useFindDriverById } from './useFindDriverById';

apps/website/hooks/driver/useCreateDriver.ts

@@ -0,0 +1,17 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { DRIVER_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+import type { CompleteOnboardingInputDTO } from '@/lib/types/generated/CompleteOnboardingInputDTO';
+import { CompleteOnboardingViewModel } from '@/lib/view-models/CompleteOnboardingViewModel';
+
+export function useCreateDriver(
+  options?: Omit<UseMutationOptions<CompleteOnboardingViewModel, ApiError, CompleteOnboardingInputDTO>, 'mutationFn'>
+) {
+  const driverService = useInject(DRIVER_SERVICE_TOKEN);
+
+  return useMutation<CompleteOnboardingViewModel, ApiError, CompleteOnboardingInputDTO>({
+    mutationFn: (input) => driverService.completeDriverOnboarding(input),
+    ...options,
+  });
+}

apps/website/hooks/driver/useCurrentDriver.ts

@@ -0,0 +1,21 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { DRIVER_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+type DriverData = any; // Replace with actual type
+
+export function useCurrentDriver(
+  options?: Omit<UseQueryOptions<DriverData, ApiError>, 'queryKey' | 'queryFn'>
+) {
+  const driverService = useInject(DRIVER_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['currentDriver'],
+    queryFn: () => driverService.getCurrentDriver(),
+    ...options,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/driver/useDriverLeaderboard.ts

@@ -0,0 +1,15 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { DRIVER_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useDriverLeaderboard() {
+  const driverService = useInject(DRIVER_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['driverLeaderboard'],
+    queryFn: () => driverService.getDriverLeaderboard(),
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/driver/useDriverProfile.ts

@@ -0,0 +1,22 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { DRIVER_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+import { ApiError } from '@/lib/api/base/ApiError';
+import { DriverProfileViewModel } from '@/lib/view-models/DriverProfileViewModel';
+
+export function useDriverProfile(
+  driverId: string,
+  options?: Omit<UseQueryOptions<DriverProfileViewModel, ApiError>, 'queryKey' | 'queryFn'>
+) {
+  const driverService = useInject(DRIVER_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['driverProfile', driverId],
+    queryFn: () => driverService.getDriverProfile(driverId),
+    enabled: !!driverId,
+    ...options,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/driver/useFindDriverById.ts

@@ -0,0 +1,22 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { DRIVER_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+import { ApiError } from '@/lib/api/base/ApiError';
+import type { GetDriverOutputDTO } from '@/lib/types/generated/GetDriverOutputDTO';
+
+export function useFindDriverById(
+  driverId: string,
+  options?: Omit<UseQueryOptions<GetDriverOutputDTO | null, ApiError>, 'queryKey' | 'queryFn'>
+) {
+  const driverService = useInject(DRIVER_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['driver', driverId],
+    queryFn: () => driverService.findById(driverId),
+    enabled: !!driverId,
+    ...options,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/driver/useUpdateDriverProfile.ts

@@ -0,0 +1,16 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { DRIVER_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+import { DriverProfileViewModel } from '@/lib/view-models/DriverProfileViewModel';
+
+export function useUpdateDriverProfile(
+  options?: Omit<UseMutationOptions<DriverProfileViewModel, ApiError, { bio?: string; country?: string }>, 'mutationFn'>
+) {
+  const driverService = useInject(DRIVER_SERVICE_TOKEN);
+
+  return useMutation<DriverProfileViewModel, ApiError, { bio?: string; country?: string }>({
+    mutationFn: (updates) => driverService.updateProfile(updates),
+    ...options,
+  });
+}

apps/website/hooks/league/useAllLeagues.ts

@@ -0,0 +1,15 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useAllLeagues() {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['allLeagues'],
+    queryFn: () => leagueService.getAllLeagues(),
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/league/useAllLeaguesWithSponsors.ts

@@ -0,0 +1,15 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useAllLeaguesWithSponsors() {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['allLeaguesWithSponsors'],
+    queryFn: () => leagueService.getAllLeagues(),
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/league/useCreateLeague.ts

@@ -0,0 +1,19 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_SERVICE_TOKEN } from '@/lib/di/tokens';
+
+export function useCreateLeague() {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+  const queryClient = useQueryClient();
+
+  const createLeagueMutation = useMutation({
+    mutationFn: (input: any) => leagueService.createLeague(input),
+    onSuccess: () => {
+      // Invalidate relevant queries to refresh data
+      queryClient.invalidateQueries({ queryKey: ['allLeagues'] });
+      queryClient.invalidateQueries({ queryKey: ['leagueMemberships'] });
+    },
+  });
+
+  return createLeagueMutation;
+}

apps/website/hooks/league/useLeagueAdminStatus.ts

@@ -0,0 +1,21 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_MEMBERSHIP_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { LeagueRoleUtility } from '@/lib/utilities/LeagueRoleUtility';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useLeagueAdminStatus(leagueId: string, currentDriverId: string) {
+  const leagueMembershipService = useInject(LEAGUE_MEMBERSHIP_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['leagueMembership', leagueId, currentDriverId],
+    queryFn: async () => {
+      await leagueMembershipService.fetchLeagueMemberships(leagueId);
+      const membership = leagueMembershipService.getMembership(leagueId, currentDriverId);
+      return membership ? LeagueRoleUtility.isLeagueAdminOrHigherRole(membership.role) : false;
+    },
+    enabled: !!leagueId && !!currentDriverId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/league/useLeagueDetail.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useLeagueDetail(leagueId: string, currentDriverId: string) {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['leagueDetail', leagueId, currentDriverId],
+    queryFn: () => leagueService.getLeagueDetail(leagueId, currentDriverId),
+    enabled: !!leagueId && !!currentDriverId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/league/useLeagueDetailWithSponsors.ts

@@ -0,0 +1,21 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+import { ApiError } from '@/lib/api/base/ApiError';
+import type { LeagueDetailPageViewModel } from '@/lib/view-models/LeagueDetailPageViewModel';
+
+export function useLeagueDetailWithSponsors(
+  leagueId: string,
+  options?: Omit<UseQueryOptions<LeagueDetailPageViewModel | null, ApiError>, 'queryKey' | 'queryFn'>
+) {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['leagueDetailWithSponsors', leagueId],
+    queryFn: () => leagueService.getLeagueDetailPageData(leagueId),
+    ...options,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/league/useLeagueMembershipMutation.ts

@@ -0,0 +1,31 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_MEMBERSHIP_SERVICE_TOKEN } from '@/lib/di/tokens';
+
+export function useLeagueMembershipMutation() {
+  const leagueMembershipService = useInject(LEAGUE_MEMBERSHIP_SERVICE_TOKEN);
+  const queryClient = useQueryClient();
+
+  const joinLeagueMutation = useMutation({
+    mutationFn: ({ leagueId, driverId }: { leagueId: string; driverId: string }) =>
+      leagueMembershipService.joinLeague(leagueId, driverId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['leagueMemberships'] });
+      queryClient.invalidateQueries({ queryKey: ['allLeagues'] });
+    },
+  });
+
+  const leaveLeagueMutation = useMutation({
+    mutationFn: ({ leagueId, driverId }: { leagueId: string; driverId: string }) =>
+      leagueMembershipService.leaveLeague(leagueId, driverId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['leagueMemberships'] });
+      queryClient.invalidateQueries({ queryKey: ['allLeagues'] });
+    },
+  });
+
+  return {
+    joinLeague: joinLeagueMutation,
+    leaveLeague: leaveLeagueMutation,
+  };
+}

apps/website/hooks/league/useLeagueMemberships.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useLeagueMemberships(leagueId: string, currentUserId: string) {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['leagueMemberships', leagueId, currentUserId],
+    queryFn: () => leagueService.getLeagueMemberships(leagueId, currentUserId),
+    enabled: !!leagueId && !!currentUserId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/league/useLeagueRaces.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { RACE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useLeagueRaces(leagueId: string) {
+  const raceService = useInject(RACE_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['leagueRaces', leagueId],
+    queryFn: () => raceService.findByLeagueId(leagueId),
+    enabled: !!leagueId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/league/useLeagueRosterAdmin.ts

@@ -0,0 +1,82 @@
+import { useQuery, useMutation, UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+import { ApiError } from '@/lib/api/base/ApiError';
+import type { LeagueAdminRosterJoinRequestViewModel } from '@/lib/view-models/LeagueAdminRosterJoinRequestViewModel';
+import type { LeagueAdminRosterMemberViewModel } from '@/lib/view-models/LeagueAdminRosterMemberViewModel';
+import type { MembershipRole } from '@/lib/types/MembershipRole';
+
+export function useLeagueRosterJoinRequests(
+  leagueId: string,
+  options?: Omit<UseQueryOptions<LeagueAdminRosterJoinRequestViewModel[], ApiError>, 'queryKey' | 'queryFn'>
+) {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['leagueRosterJoinRequests', leagueId],
+    queryFn: () => leagueService.getAdminRosterJoinRequests(leagueId),
+    ...options,
+  });
+
+  return enhanceQueryResult(queryResult);
+}
+
+export function useLeagueRosterMembers(
+  leagueId: string,
+  options?: Omit<UseQueryOptions<LeagueAdminRosterMemberViewModel[], ApiError>, 'queryKey' | 'queryFn'>
+) {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['leagueRosterMembers', leagueId],
+    queryFn: () => leagueService.getAdminRosterMembers(leagueId),
+    ...options,
+  });
+
+  return enhanceQueryResult(queryResult);
+}
+
+export function useApproveJoinRequest(
+  options?: Omit<UseMutationOptions<{ success: boolean }, ApiError, { leagueId: string; joinRequestId: string }>, 'mutationFn'>
+) {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+
+  return useMutation<{ success: boolean }, ApiError, { leagueId: string; joinRequestId: string }>({
+    mutationFn: ({ leagueId, joinRequestId }) => leagueService.approveJoinRequest(leagueId, joinRequestId),
+    ...options,
+  });
+}
+
+export function useRejectJoinRequest(
+  options?: Omit<UseMutationOptions<{ success: boolean }, ApiError, { leagueId: string; joinRequestId: string }>, 'mutationFn'>
+) {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+
+  return useMutation<{ success: boolean }, ApiError, { leagueId: string; joinRequestId: string }>({
+    mutationFn: ({ leagueId, joinRequestId }) => leagueService.rejectJoinRequest(leagueId, joinRequestId),
+    ...options,
+  });
+}
+
+export function useUpdateMemberRole(
+  options?: Omit<UseMutationOptions<{ success: boolean }, ApiError, { leagueId: string; driverId: string; role: MembershipRole }>, 'mutationFn'>
+) {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+
+  return useMutation<{ success: boolean }, ApiError, { leagueId: string; driverId: string; role: MembershipRole }>({
+    mutationFn: ({ leagueId, driverId, role }) => leagueService.updateMemberRole(leagueId, driverId, role),
+    ...options,
+  });
+}
+
+export function useRemoveMember(
+  options?: Omit<UseMutationOptions<{ success: boolean }, ApiError, { leagueId: string; driverId: string }>, 'mutationFn'>
+) {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+
+  return useMutation<{ success: boolean }, ApiError, { leagueId: string; driverId: string }>({
+    mutationFn: ({ leagueId, driverId }) => leagueService.removeMember(leagueId, driverId),
+    ...options,
+  });
+}

apps/website/hooks/league/useLeagueSchedule.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useLeagueSchedule(leagueId: string) {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['leagueSchedule', leagueId],
+    queryFn: () => leagueService.getLeagueSchedule(leagueId),
+    enabled: !!leagueId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/league/useLeagueSeasons.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useLeagueSeasons(leagueId: string) {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['leagueSeasons', leagueId],
+    queryFn: () => leagueService.getLeagueSeasons(leagueId),
+    enabled: !!leagueId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/league/useLeagueSettings.ts

@@ -0,0 +1,22 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_SETTINGS_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+import { ApiError } from '@/lib/api/base/ApiError';
+import type { LeagueSettingsViewModel } from '@/lib/view-models/LeagueSettingsViewModel';
+
+export function useLeagueSettings(
+  leagueId: string,
+  options?: Omit<UseQueryOptions<LeagueSettingsViewModel | null, ApiError>, 'queryKey' | 'queryFn'>
+) {
+  const leagueSettingsService = useInject(LEAGUE_SETTINGS_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['leagueSettings', leagueId],
+    queryFn: () => leagueSettingsService.getLeagueSettings(leagueId),
+    enabled: !!leagueId,
+    ...options,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/league/useLeagueStewardingData.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_STEWARDING_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useLeagueStewardingData(leagueId: string) {
+  const leagueStewardingService = useInject(LEAGUE_STEWARDING_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['leagueStewardingData', leagueId],
+    queryFn: () => leagueStewardingService.getLeagueStewardingData(leagueId),
+    enabled: !!leagueId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/league/useLeagueWallet.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_WALLET_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useLeagueWallet(leagueId: string) {
+  const leagueWalletService = useInject(LEAGUE_WALLET_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['leagueWallet', leagueId],
+    queryFn: () => leagueWalletService.getWalletForLeague(leagueId),
+    enabled: !!leagueId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/league/usePenaltyMutation.ts

@@ -0,0 +1,19 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { PENALTY_SERVICE_TOKEN } from '@/lib/di/tokens';
+
+export function usePenaltyMutation() {
+  const penaltyService = useInject(PENALTY_SERVICE_TOKEN);
+  const queryClient = useQueryClient();
+
+  const applyPenaltyMutation = useMutation({
+    mutationFn: (command: any) => penaltyService.applyPenalty(command),
+    onSuccess: () => {
+      // Invalidate relevant queries to refresh data
+      queryClient.invalidateQueries({ queryKey: ['leagueStewardingData'] });
+      queryClient.invalidateQueries({ queryKey: ['penalties'] });
+    },
+  });
+
+  return applyPenaltyMutation;
+}

apps/website/hooks/league/useProtestDetail.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_STEWARDING_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useProtestDetail(leagueId: string, protestId: string, enabled: boolean = true) {
+  const leagueStewardingService = useInject(LEAGUE_STEWARDING_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['protestDetail', leagueId, protestId],
+    queryFn: () => leagueStewardingService.getProtestDetailViewModel(leagueId, protestId),
+    enabled: enabled && !!leagueId && !!protestId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/league/useSponsorshipRequests.ts

@@ -0,0 +1,19 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { SPONSORSHIP_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useSponsorshipRequests(entityType: string, entityId: string) {
+  const sponsorshipService = useInject(SPONSORSHIP_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['sponsorshipRequests', entityType, entityId],
+    queryFn: () => sponsorshipService.getPendingSponsorshipRequests({
+      entityType,
+      entityId,
+    }),
+    enabled: !!entityType && !!entityId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/onboarding/index.ts

@@ -0,0 +1,3 @@
+export { useCompleteOnboarding } from './useCompleteOnboarding';
+export { useGenerateAvatars } from './useGenerateAvatars';
+export { useValidateFacePhoto } from './useValidateFacePhoto';

apps/website/hooks/onboarding/useCompleteOnboarding.ts

@@ -0,0 +1,17 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { ONBOARDING_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+import { CompleteOnboardingViewModel } from '@/lib/view-models/CompleteOnboardingViewModel';
+import type { CompleteOnboardingInputDTO } from '@/lib/types/generated/CompleteOnboardingInputDTO';
+
+export function useCompleteOnboarding(
+  options?: Omit<UseMutationOptions<CompleteOnboardingViewModel, ApiError, CompleteOnboardingInputDTO>, 'mutationFn'>
+) {
+  const onboardingService = useInject(ONBOARDING_SERVICE_TOKEN);
+
+  return useMutation<CompleteOnboardingViewModel, ApiError, CompleteOnboardingInputDTO>({
+    mutationFn: (input) => onboardingService.completeOnboarding(input),
+    ...options,
+  });
+}

apps/website/hooks/onboarding/useGenerateAvatars.ts

@@ -0,0 +1,22 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { ONBOARDING_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+import { AvatarGenerationViewModel } from '@/lib/view-models/AvatarGenerationViewModel';
+
+interface GenerateAvatarsParams {
+  userId: string;
+  facePhotoData: string;
+  suitColor: string;
+}
+
+export function useGenerateAvatars(
+  options?: Omit<UseMutationOptions<AvatarGenerationViewModel, ApiError, GenerateAvatarsParams>, 'mutationFn'>
+) {
+  const onboardingService = useInject(ONBOARDING_SERVICE_TOKEN);
+
+  return useMutation<AvatarGenerationViewModel, ApiError, GenerateAvatarsParams>({
+    mutationFn: (params) => onboardingService.generateAvatars(params.userId, params.facePhotoData, params.suitColor),
+    ...options,
+  });
+}

apps/website/hooks/onboarding/useValidateFacePhoto.ts

@@ -0,0 +1,15 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { ONBOARDING_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+export function useValidateFacePhoto(
+  options?: Omit<UseMutationOptions<{ isValid: boolean; errorMessage?: string }, ApiError, string>, 'mutationFn'>
+) {
+  const onboardingService = useInject(ONBOARDING_SERVICE_TOKEN);
+
+  return useMutation<{ isValid: boolean; errorMessage?: string }, ApiError, string>({
+    mutationFn: (photoData) => onboardingService.validateFacePhoto(photoData),
+    ...options,
+  });
+}

apps/website/hooks/penalty/useRacePenalties.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { PENALTY_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useRacePenalties(raceId: string) {
+  const penaltyService = useInject(PENALTY_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['racePenalties', raceId],
+    queryFn: () => penaltyService.findByRaceId(raceId),
+    enabled: !!raceId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/protest/useLeagueProtests.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { PROTEST_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useLeagueProtests(leagueId: string) {
+  const protestService = useInject(PROTEST_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['leagueProtests', leagueId],
+    queryFn: () => protestService.getLeagueProtests(leagueId),
+    enabled: !!leagueId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/race/useCancelRace.ts

@@ -0,0 +1,15 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { RACE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+export function useCancelRace(
+  options?: Omit<UseMutationOptions<void, ApiError, string>, 'mutationFn'>
+) {
+  const raceService = useInject(RACE_SERVICE_TOKEN);
+
+  return useMutation<void, ApiError, string>({
+    mutationFn: (raceId) => raceService.cancelRace(raceId),
+    ...options,
+  });
+}

apps/website/hooks/race/useCompleteRace.ts

@@ -0,0 +1,15 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { RACE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+export function useCompleteRace(
+  options?: Omit<UseMutationOptions<void, ApiError, string>, 'mutationFn'>
+) {
+  const raceService = useInject(RACE_SERVICE_TOKEN);
+
+  return useMutation<void, ApiError, string>({
+    mutationFn: (raceId) => raceService.completeRace(raceId),
+    ...options,
+  });
+}

apps/website/hooks/race/useFileProtest.ts

@@ -0,0 +1,16 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { RACE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+import type { FileProtestCommandDTO } from '@/lib/types/generated/FileProtestCommandDTO';
+
+export function useFileProtest(
+  options?: Omit<UseMutationOptions<void, ApiError, FileProtestCommandDTO>, 'mutationFn'>
+) {
+  const raceService = useInject(RACE_SERVICE_TOKEN);
+
+  return useMutation<void, ApiError, FileProtestCommandDTO>({
+    mutationFn: (command) => raceService.fileProtest(command),
+    ...options,
+  });
+}

apps/website/hooks/race/useRaceDetail.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { RACE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useRaceDetail(raceId: string, driverId: string) {
+  const raceService = useInject(RACE_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['raceDetail', raceId, driverId],
+    queryFn: () => raceService.getRaceDetail(raceId, driverId),
+    enabled: !!raceId && !!driverId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/race/useRaceResultsDetail.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { RACE_RESULTS_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useRaceResultsDetail(raceId: string, currentUserId?: string) {
+  const raceResultsService = useInject(RACE_RESULTS_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['raceResultsDetail', raceId, currentUserId],
+    queryFn: () => raceResultsService.getResultsDetail(raceId, currentUserId),
+    enabled: !!raceId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/race/useRaceStewardingData.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { RACE_STEWARDING_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useRaceStewardingData(raceId: string, currentDriverId?: string) {
+  const raceStewardingService = useInject(RACE_STEWARDING_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['raceStewardingData', raceId, currentDriverId],
+    queryFn: () => raceStewardingService.getRaceStewardingData(raceId, currentDriverId || ''),
+    enabled: !!raceId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/race/useRaceWithSOF.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { RACE_RESULTS_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useRaceWithSOF(raceId: string) {
+  const raceResultsService = useInject(RACE_RESULTS_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['raceWithSOF', raceId],
+    queryFn: () => raceResultsService.getWithSOF(raceId),
+    enabled: !!raceId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/race/useRacesPageData.ts

@@ -0,0 +1,15 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { RACE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useRacesPageData() {
+  const raceService = useInject(RACE_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['racesPageData'],
+    queryFn: () => raceService.getRacesPageData(),
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/race/useRegisterForRace.ts

@@ -0,0 +1,21 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { RACE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+interface RegisterForRaceParams {
+  raceId: string;
+  leagueId: string;
+  driverId: string;
+}
+
+export function useRegisterForRace(
+  options?: Omit<UseMutationOptions<void, ApiError, RegisterForRaceParams>, 'mutationFn'>
+) {
+  const raceService = useInject(RACE_SERVICE_TOKEN);
+
+  return useMutation<void, ApiError, RegisterForRaceParams>({
+    mutationFn: (params) => raceService.registerForRace(params.raceId, params.leagueId, params.driverId),
+    ...options,
+  });
+}

apps/website/hooks/race/useReopenRace.ts

@@ -0,0 +1,15 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { RACE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+export function useReopenRace(
+  options?: Omit<UseMutationOptions<void, ApiError, string>, 'mutationFn'>
+) {
+  const raceService = useInject(RACE_SERVICE_TOKEN);
+
+  return useMutation<void, ApiError, string>({
+    mutationFn: (raceId) => raceService.reopenRace(raceId),
+    ...options,
+  });
+}

apps/website/hooks/race/useWithdrawFromRace.ts

@@ -0,0 +1,20 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { RACE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+interface WithdrawFromRaceParams {
+  raceId: string;
+  driverId: string;
+}
+
+export function useWithdrawFromRace(
+  options?: Omit<UseMutationOptions<void, ApiError, WithdrawFromRaceParams>, 'mutationFn'>
+) {
+  const raceService = useInject(RACE_SERVICE_TOKEN);
+
+  return useMutation<void, ApiError, WithdrawFromRaceParams>({
+    mutationFn: (params) => raceService.withdrawFromRace(params.raceId, params.driverId),
+    ...options,
+  });
+}

apps/website/hooks/sponsor/index.ts

@@ -0,0 +1,5 @@
+export { useAvailableLeagues } from './useAvailableLeagues';
+export { useSponsorDashboard } from './useSponsorDashboard';
+export { useSponsorSponsorships } from './useSponsorSponsorships';
+export { useSponsorBilling } from './useSponsorBilling';
+export { useSponsorLeagueDetail } from './useSponsorLeagueDetail';

apps/website/hooks/sponsor/useAvailableLeagues.ts

@@ -0,0 +1,15 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { SPONSOR_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useAvailableLeagues() {
+  const sponsorService = useInject(SPONSOR_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['availableLeagues'],
+    queryFn: () => sponsorService.getAvailableLeagues(),
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/sponsor/useSponsorBilling.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { SPONSOR_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useSponsorBilling(sponsorId: string) {
+  const sponsorService = useInject(SPONSOR_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['sponsorBilling', sponsorId],
+    queryFn: () => sponsorService.getBilling(sponsorId),
+    enabled: !!sponsorId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/sponsor/useSponsorDashboard.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { SPONSOR_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useSponsorDashboard(sponsorId: string) {
+  const sponsorService = useInject(SPONSOR_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['sponsorDashboard', sponsorId],
+    queryFn: () => sponsorService.getSponsorDashboard(sponsorId),
+    enabled: !!sponsorId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/sponsor/useSponsorLeagueDetail.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { SPONSOR_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useSponsorLeagueDetail(leagueId: string) {
+  const sponsorService = useInject(SPONSOR_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['sponsorLeagueDetail', leagueId],
+    queryFn: () => sponsorService.getLeagueDetail(leagueId),
+    enabled: !!leagueId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/sponsor/useSponsorSponsorships.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { SPONSOR_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useSponsorSponsorships(sponsorId: string) {
+  const sponsorService = useInject(SPONSOR_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['sponsorSponsorships', sponsorId],
+    queryFn: () => sponsorService.getSponsorSponsorships(sponsorId),
+    enabled: !!sponsorId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/team/index.ts

@@ -0,0 +1,13 @@
+export { useAllTeams } from './useAllTeams';
+export { useTeamDetails } from './useTeamDetails';
+export { useTeamMembers } from './useTeamMembers';
+export { useTeamJoinRequests } from './useTeamJoinRequests';
+export { useCreateTeam } from './useCreateTeam';
+export { useUpdateTeam } from './useUpdateTeam';
+export { useTeamMembership } from './useTeamMembership';
+export { useApproveJoinRequest } from './useApproveJoinRequest';
+export { useRejectJoinRequest } from './useRejectJoinRequest';
+export { useTeamStandings } from './useTeamStandings';
+export { useJoinTeam } from './useJoinTeam';
+export { useLeaveTeam } from './useLeaveTeam';
+export { useTeamRoster } from './useTeamRoster';

apps/website/hooks/team/useAllTeams.ts

@@ -0,0 +1,15 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { TEAM_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useAllTeams() {
+  const teamService = useInject(TEAM_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['allTeams'],
+    queryFn: () => teamService.getAllTeams(),
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/team/useApproveJoinRequest.ts

@@ -0,0 +1,13 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { TEAM_JOIN_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+export function useApproveJoinRequest(options?: Omit<UseMutationOptions<void, ApiError, void>, 'mutationFn'>) {
+  const teamJoinService = useInject(TEAM_JOIN_SERVICE_TOKEN);
+
+  return useMutation<void, ApiError, void>({
+    mutationFn: () => teamJoinService.approveJoinRequest(),
+    ...options,
+  });
+}

apps/website/hooks/team/useCreateTeam.ts

@@ -0,0 +1,15 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { TEAM_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+import type { CreateTeamInputDTO } from '@/lib/types/generated/CreateTeamInputDTO';
+import type { CreateTeamOutputDTO } from '@/lib/types/generated/CreateTeamOutputDTO';
+
+export function useCreateTeam(options?: UseMutationOptions<CreateTeamOutputDTO, ApiError, CreateTeamInputDTO>) {
+  const teamService = useInject(TEAM_SERVICE_TOKEN);
+
+  return useMutation<CreateTeamOutputDTO, ApiError, CreateTeamInputDTO>({
+    mutationFn: (input) => teamService.createTeam(input),
+    ...options,
+  });
+}

apps/website/hooks/team/useJoinTeam.ts

@@ -0,0 +1,28 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { TEAM_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+interface JoinTeamParams {
+  teamId: string;
+  driverId: string;
+  requiresApproval?: boolean;
+}
+
+export function useJoinTeam(options?: Omit<UseMutationOptions<void, ApiError, JoinTeamParams>, 'mutationFn'>) {
+  const teamService = useInject(TEAM_SERVICE_TOKEN);
+
+  return useMutation<void, ApiError, JoinTeamParams>({
+    mutationFn: async (params) => {
+      // Note: Team join functionality would need to be added to teamService
+      // For now, we'll use a placeholder
+      console.log('Joining team:', params);
+      if (params.requiresApproval) {
+        alert('Join request sent! Wait for team approval.');
+      } else {
+        alert('Successfully joined team!');
+      }
+    },
+    ...options,
+  });
+}

apps/website/hooks/team/useLeaveTeam.ts

@@ -0,0 +1,23 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { TEAM_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+interface LeaveTeamParams {
+  teamId: string;
+  driverId: string;
+}
+
+export function useLeaveTeam(options?: Omit<UseMutationOptions<void, ApiError, LeaveTeamParams>, 'mutationFn'>) {
+  const teamService = useInject(TEAM_SERVICE_TOKEN);
+
+  return useMutation<void, ApiError, LeaveTeamParams>({
+    mutationFn: async (params) => {
+      // Note: Leave team functionality would need to be added to teamService
+      // For now, we'll use a placeholder
+      console.log('Leaving team:', params);
+      alert('Successfully left team');
+    },
+    ...options,
+  });
+}

apps/website/hooks/team/useRejectJoinRequest.ts

@@ -0,0 +1,13 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { TEAM_JOIN_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+
+export function useRejectJoinRequest(options?: Omit<UseMutationOptions<void, ApiError, void>, 'mutationFn'>) {
+  const teamJoinService = useInject(TEAM_JOIN_SERVICE_TOKEN);
+
+  return useMutation<void, ApiError, void>({
+    mutationFn: () => teamJoinService.rejectJoinRequest(),
+    ...options,
+  });
+}

apps/website/hooks/team/useTeamDetails.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { TEAM_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useTeamDetails(teamId: string, currentUserId: string) {
+  const teamService = useInject(TEAM_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['teamDetails', teamId, currentUserId],
+    queryFn: () => teamService.getTeamDetails(teamId, currentUserId),
+    enabled: !!teamId && !!currentUserId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/team/useTeamJoinRequests.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { TEAM_JOIN_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useTeamJoinRequests(teamId: string, currentUserId: string, isOwner: boolean) {
+  const teamJoinService = useInject(TEAM_JOIN_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['teamJoinRequests', teamId, currentUserId, isOwner],
+    queryFn: () => teamJoinService.getJoinRequests(teamId, currentUserId, isOwner),
+    enabled: !!teamId && !!currentUserId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/team/useTeamMembers.ts

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { TEAM_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useTeamMembers(teamId: string, currentUserId: string, teamOwnerId: string) {
+  const teamService = useInject(TEAM_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['teamMembers', teamId, currentUserId, teamOwnerId],
+    queryFn: () => teamService.getTeamMembers(teamId, currentUserId, teamOwnerId),
+    enabled: !!teamId && !!currentUserId && !!teamOwnerId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/team/useTeamMembership.ts

@@ -0,0 +1,17 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { TEAM_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+import type { GetTeamMembershipOutputDTO } from '@/lib/types/generated/GetTeamMembershipOutputDTO';
+
+export function useTeamMembership(teamId: string, driverId: string) {
+  const teamService = useInject(TEAM_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['teamMembership', teamId, driverId],
+    queryFn: () => teamService.getMembership(teamId, driverId),
+    enabled: !!teamId && !!driverId,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/team/useTeamRoster.ts

@@ -0,0 +1,41 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { TEAM_SERVICE_TOKEN, DRIVER_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+import type { TeamMemberViewModel } from '@/lib/view-models/TeamMemberViewModel';
+
+interface TeamRosterMember {
+  driver: any;
+  role: string;
+  joinedAt: string;
+  rating: number | null;
+  overallRank: number | null;
+}
+
+export function useTeamRoster(memberships: TeamMemberViewModel[]) {
+  const teamService = useInject(TEAM_SERVICE_TOKEN);
+  const driverService = useInject(DRIVER_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['teamRoster', memberships],
+    queryFn: async () => {
+      // Get driver details for each membership
+      const membersWithDetails = await Promise.all(
+        memberships.map(async (m) => {
+          const driver = await driverService.findById(m.driverId);
+          return {
+            driver: driver || { id: m.driverId, name: 'Unknown Driver', country: 'Unknown', position: 'N/A', races: '0', impressions: '0', team: 'None' },
+            role: m.role,
+            joinedAt: m.joinedAt,
+            rating: null, // DriverDTO doesn't include rating
+            overallRank: null, // DriverDTO doesn't include overallRank
+          };
+        })
+      );
+      return membersWithDetails;
+    },
+    enabled: memberships.length > 0,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/team/useTeamStandings.ts

@@ -0,0 +1,26 @@
+import { useQuery } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+
+export function useTeamStandings(teamId: string, leagues: string[]) {
+  const leagueService = useInject(LEAGUE_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['teamStandings', teamId, leagues],
+    queryFn: async () => {
+      // For demo purposes, create mock standings
+      return leagues.map(leagueId => ({
+        leagueId,
+        leagueName: `League ${leagueId}`,
+        position: Math.floor(Math.random() * 10) + 1,
+        points: Math.floor(Math.random() * 100),
+        wins: Math.floor(Math.random() * 5),
+        racesCompleted: Math.floor(Math.random() * 10),
+      }));
+    },
+    enabled: leagues.length > 0,
+  });
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/team/useUpdateTeam.ts

@@ -0,0 +1,15 @@
+import { useMutation, UseMutationOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { TEAM_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { ApiError } from '@/lib/api/base/ApiError';
+import type { UpdateTeamInputDTO } from '@/lib/types/generated/UpdateTeamInputDTO';
+import type { UpdateTeamOutputDTO } from '@/lib/types/generated/UpdateTeamOutputDTO';
+
+export function useUpdateTeam(options?: UseMutationOptions<UpdateTeamOutputDTO, ApiError, { teamId: string; input: UpdateTeamInputDTO }>) {
+  const teamService = useInject(TEAM_SERVICE_TOKEN);
+
+  return useMutation<UpdateTeamOutputDTO, ApiError, { teamId: string; input: UpdateTeamInputDTO }>({
+    mutationFn: ({ teamId, input }) => teamService.updateTeam(teamId, input),
+    ...options,
+  });
+}

apps/website/hooks/useCapability.ts

@@ -0,0 +1,35 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { useInject } from '@/lib/di/hooks/useInject';
+import { POLICY_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
+import { ApiError } from '@/lib/api/base/ApiError';
+import { PolicySnapshotDto } from '@/lib/api/policy/PolicyApiClient';
+
+export function useCapability(
+  capabilityKey: string,
+  options?: Omit<UseQueryOptions<PolicySnapshotDto, ApiError>, 'queryKey' | 'queryFn'>
+) {
+  const policyService = useInject(POLICY_SERVICE_TOKEN);
+
+  const queryResult = useQuery({
+    queryKey: ['policySnapshot', capabilityKey],
+    queryFn: () => policyService.getSnapshot(),
+    staleTime: 60_000,
+    gcTime: 5 * 60_000,
+    ...options,
+  });
+
+  const enhancedResult = enhanceQueryResult(queryResult);
+
+  // Add helper to get capability state
+  const capabilityState = enhancedResult.data 
+    ? policyService.getCapabilityState(enhancedResult.data, capabilityKey)
+    : null;
+
+  return {
+    ...enhancedResult,
+    capabilityState,
+    isCapabilityEnabled: capabilityState === 'enabled',
+    isCapabilityComingSoon: capabilityState === 'coming_soon',
+  };
+}

apps/website/hooks/useDashboardService.ts

@@ -1,11 +0,0 @@
-import { useQuery } from '@tanstack/react-query';
-import { useServices } from '@/lib/services/ServiceProvider';
-
-export function useDashboardOverview() {
-  const { dashboardService } = useServices();
-
-  return useQuery({
-    queryKey: ['dashboardOverview'],
-    queryFn: () => dashboardService.getDashboardOverview(),
-  });
-}

apps/website/hooks/useDriverService.ts

@@ -1,80 +0,0 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { useServices } from '@/lib/services/ServiceProvider';
-import { CompleteOnboardingInputDTO } from '@/lib/types/generated/CompleteOnboardingInputDTO';
-import { DriverLeaderboardViewModel } from '@/lib/view-models/DriverLeaderboardViewModel';
-import { DriverViewModel } from '@/lib/view-models/DriverViewModel';
-import { DriverProfileViewModel } from '@/lib/view-models/DriverProfileViewModel';
-import type { DriverDTO } from '@/lib/types/generated/DriverDTO';
-
-export function useDriverLeaderboard() {
-  const { driverService } = useServices();
-
-  return useQuery({
-    queryKey: ['driverLeaderboard'],
-    queryFn: () => driverService.getDriverLeaderboard(),
-  });
-}
-
-export function useCurrentDriver() {
-  const { driverService } = useServices();
-
-  return useQuery({
-    queryKey: ['currentDriver'],
-    queryFn: () => driverService.getCurrentDriver(),
-  });
-}
-
-export function useDriverProfile(driverId: string) {
-  const { driverService } = useServices();
-
-  return useQuery({
-    queryKey: ['driverProfile', driverId],
-    queryFn: () => driverService.getDriverProfile(driverId),
-    enabled: !!driverId,
-  });
-}
-
-export function useCompleteDriverOnboarding() {
-  const { driverService } = useServices();
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (input: CompleteOnboardingInputDTO) => driverService.completeDriverOnboarding(input),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['currentDriver'] });
-    },
-  });
-}
-
-export function useUpdateDriverProfile() {
-  const { driverService } = useServices();
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (updates: { bio?: string; country?: string }) => driverService.updateProfile(updates),
-    onSuccess: (data, variables) => {
-      queryClient.invalidateQueries({ queryKey: ['driverProfile', data.currentDriver?.id] });
-      queryClient.invalidateQueries({ queryKey: ['currentDriver'] });
-    },
-  });
-}
-
-export function useFindDriverById(id: string) {
-  const { driverService } = useServices();
-
-  return useQuery({
-    queryKey: ['driver', id],
-    queryFn: () => driverService.findById(id),
-    enabled: !!id,
-  });
-}
-
-export function useFindDriversByIds(ids: string[]) {
-  const { driverService } = useServices();
-
-  return useQuery({
-    queryKey: ['drivers', ids],
-    queryFn: () => driverService.findByIds(ids),
-    enabled: ids.length > 0,
-  });
-}

apps/website/hooks/useEffectiveDriverId.ts

@@ -1,26 +1,10 @@
-'use client';
-
-import { useAuth } from '@/lib/auth/AuthContext';
+import { useCurrentDriver } from './driver/useCurrentDriver';
 
 /**
- * Returns the effective driver ID for the current session.
- *
- * Prefers the authenticated user's primaryDriverId when available,
- * otherwise returns an empty string (user must log in to have a driver).
+ * Hook to get the current driver ID from the user's session.
+ * Returns the driver ID string or undefined if not available.
  */
-export function useEffectiveDriverId(): string {
-  const { session } = useAuth();
-  const user = session?.user as
-    | {
-        primaryDriverId?: string | null;
-      }
-    | undefined;
-
-  // Return the user's primary driver ID if available
-  if (user?.primaryDriverId) {
-    return user.primaryDriverId;
-  }
-
-  // No driver ID available - user needs to log in or complete onboarding
-  return '';
+export function useEffectiveDriverId(): string | undefined {
+  const { data: currentDriver } = useCurrentDriver();
+  return currentDriver?.id;
 }

apps/website/hooks/useLeagueMembershipService.ts

@@ -1,26 +1,16 @@
 import { useQuery } from '@tanstack/react-query';
-import { useServices } from '@/lib/services/ServiceProvider';
-
-export function useLeagueMemberships(leagueId: string) {
-  const { leagueMembershipService } = useServices();
-
-  return useQuery({
-    queryKey: ['leagueMemberships', leagueId],
-    queryFn: () => leagueMembershipService.fetchLeagueMemberships(leagueId),
-    enabled: !!leagueId,
-  });
-}
+import { useInject } from '@/lib/di/hooks/useInject';
+import { LEAGUE_MEMBERSHIP_SERVICE_TOKEN } from '@/lib/di/tokens';
+import { enhanceQueryResult } from '@/lib/di/hooks/useReactQueryWithApiError';
 
 export function useLeagueMembership(leagueId: string, driverId: string) {
-  const { leagueMembershipService } = useServices();
+  const leagueMembershipService = useInject(LEAGUE_MEMBERSHIP_SERVICE_TOKEN);
 
-  return useQuery({
+  const queryResult = useQuery({
     queryKey: ['leagueMembership', leagueId, driverId],
-    queryFn: async () => {
-      // First fetch memberships if not cached
-      await leagueMembershipService.fetchLeagueMemberships(leagueId);
-      return leagueMembershipService.getMembership(leagueId, driverId);
-    },
+    queryFn: () => leagueMembershipService.getMembership(leagueId, driverId),
     enabled: !!leagueId && !!driverId,
   });
-}
+
+  return enhanceQueryResult(queryResult);
+}

apps/website/hooks/useLeagueService.ts

@@ -1,125 +0,0 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { useServices } from '@/lib/services/ServiceProvider';
-import { CreateLeagueInputDTO } from '@/lib/types/generated/CreateLeagueInputDTO';
-import { LeagueSummaryViewModel } from '@/lib/view-models/LeagueSummaryViewModel';
-import { LeagueStandingsViewModel } from '@/lib/view-models/LeagueStandingsViewModel';
-import { LeagueStatsViewModel } from '@/lib/view-models/LeagueStatsViewModel';
-import { LeagueScheduleViewModel } from '@/lib/view-models/LeagueScheduleViewModel';
-import { LeagueMembershipsViewModel } from '@/lib/view-models/LeagueMembershipsViewModel';
-import { RemoveMemberViewModel } from '@/lib/view-models/RemoveMemberViewModel';
-import { LeagueDetailViewModel } from '@/lib/view-models/LeagueDetailViewModel';
-import { LeagueDetailPageViewModel } from '@/lib/view-models/LeagueDetailPageViewModel';
-
-export function useAllLeagues() {
-  const { leagueService } = useServices();
-
-  return useQuery({
-    queryKey: ['allLeagues'],
-    queryFn: () => leagueService.getAllLeagues(),
-  });
-}
-
-export function useLeagueStandings(leagueId: string, currentUserId: string) {
-  const { leagueService } = useServices();
-
-  return useQuery({
-    queryKey: ['leagueStandings', leagueId, currentUserId],
-    queryFn: () => leagueService.getLeagueStandings(leagueId, currentUserId),
-    enabled: !!leagueId && !!currentUserId,
-  });
-}
-
-export function useLeagueStats() {
-  const { leagueService } = useServices();
-
-  return useQuery({
-    queryKey: ['leagueStats'],
-    queryFn: () => leagueService.getLeagueStats(),
-  });
-}
-
-export function useLeagueSchedule(leagueId: string) {
-  const { leagueService } = useServices();
-
-  return useQuery({
-    queryKey: ['leagueSchedule', leagueId],
-    queryFn: () => leagueService.getLeagueSchedule(leagueId),
-    enabled: !!leagueId,
-  });
-}
-
-export function useLeagueMemberships(leagueId: string, currentUserId: string) {
-  const { leagueService } = useServices();
-
-  return useQuery({
-    queryKey: ['leagueMemberships', leagueId, currentUserId],
-    queryFn: () => leagueService.getLeagueMemberships(leagueId, currentUserId),
-    enabled: !!leagueId && !!currentUserId,
-  });
-}
-
-export function useCreateLeague() {
-  const { leagueService } = useServices();
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (input: CreateLeagueInputDTO) => leagueService.createLeague(input),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['allLeagues'] });
-    },
-  });
-}
-
-export function useRemoveLeagueMember() {
-  const { leagueService } = useServices();
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: ({ leagueId, performerDriverId, targetDriverId }: {
-      leagueId: string;
-      performerDriverId: string;
-      targetDriverId: string;
-    }) => leagueService.removeMember(leagueId, performerDriverId, targetDriverId),
-    onSuccess: (data, variables) => {
-      queryClient.invalidateQueries({ queryKey: ['leagueMemberships', variables.leagueId] });
-      queryClient.invalidateQueries({ queryKey: ['leagueStandings', variables.leagueId] });
-    },
-  });
-}
-
-export function useUpdateLeagueMemberRole() {
-  const { leagueService } = useServices();
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: ({ leagueId, performerDriverId, targetDriverId, newRole }: {
-      leagueId: string;
-      performerDriverId: string;
-      targetDriverId: string;
-      newRole: string;
-    }) => leagueService.updateMemberRole(leagueId, performerDriverId, targetDriverId, newRole),
-    onSuccess: (data, variables) => {
-      queryClient.invalidateQueries({ queryKey: ['leagueMemberships', variables.leagueId] });
-    },
-  });
-}
-
-export function useLeagueDetail(leagueId: string, currentDriverId: string) {
-  const { leagueService } = useServices();
-
-  return useQuery({
-    queryKey: ['leagueDetail', leagueId, currentDriverId],
-    queryFn: () => leagueService.getLeagueDetail(leagueId, currentDriverId),
-    enabled: !!leagueId && !!currentDriverId,
-  });
-}
-
-export function useLeagueDetailPageData(leagueId: string) {
-  const { leagueService } = useServices();
-
-  return useQuery({
-    queryKey: ['leagueDetailPageData', leagueId],
-    queryFn: () => leagueService.getLeagueDetailPageData(leagueId),
-    enabled: !!leagueId,
-  });
-}

apps/website/hooks/usePenaltyTypesReference.ts

@@ -1,15 +0,0 @@
-'use client';
-
-import { useQuery } from '@tanstack/react-query';
-import { useServices } from '@/lib/services/ServiceProvider';
-import type { PenaltyTypesReferenceDTO } from '@/lib/types/PenaltyTypesReferenceDTO';
-
-export function usePenaltyTypesReference() {
-  const { penaltyService } = useServices();
-
-  return useQuery<PenaltyTypesReferenceDTO>({
-    queryKey: ['penaltyTypesReference'],
-    queryFn: () => penaltyService.getPenaltyTypesReference(),
-    staleTime: 5 * 60 * 1000,
-  });
-}

apps/website/hooks/useRaceService.ts

@@ -1,155 +0,0 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { useServices } from '@/lib/services/ServiceProvider';
-import { RaceResultsDetailViewModel } from '@/lib/view-models/RaceResultsDetailViewModel';
-
-export function useRacesPageData() {
-  const { raceService } = useServices();
-
-  return useQuery({
-    queryKey: ['racesPageData'],
-    queryFn: () => raceService.getRacesPageData(),
-  });
-}
-
-export function useAllRacesPageData() {
-  const { raceService } = useServices();
-
-  return useQuery({
-    queryKey: ['allRacesPageData'],
-    queryFn: () => raceService.getAllRacesPageData(),
-  });
-}
-
-export function useRaceDetail(raceId: string, driverId: string) {
-  const { raceService } = useServices();
-
-  return useQuery({
-    queryKey: ['raceDetail', raceId, driverId],
-    queryFn: () => raceService.getRaceDetails(raceId, driverId),
-    enabled: !!raceId && !!driverId,
-  });
-}
-
-export function useRaceDetailMutation() {
-  const { raceService } = useServices();
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: ({ raceId, driverId }: { raceId: string; driverId: string }) =>
-      raceService.getRaceDetails(raceId, driverId),
-    onSuccess: (data, variables) => {
-      queryClient.setQueryData(['raceDetail', variables.raceId, variables.driverId], data);
-    },
-  });
-}
-
-export function useRaceStewardingData(raceId: string, driverId: string) {
-  const { raceStewardingService } = useServices();
-
-  return useQuery({
-    queryKey: ['raceStewardingData', raceId, driverId],
-    queryFn: () => raceStewardingService.getRaceStewardingData(raceId, driverId),
-    enabled: !!raceId && !!driverId,
-  });
-}
-
-export function useRaceResultsDetail(raceId: string, driverId: string) {
-  const { raceResultsService } = useServices();
-
-  return useQuery<RaceResultsDetailViewModel>({
-    queryKey: ['raceResultsDetail', raceId, driverId],
-    queryFn: () => raceResultsService.getResultsDetail(raceId, driverId),
-    enabled: !!raceId && !!driverId,
-  });
-}
-
-export function useRaceWithSOF(raceId: string) {
-  const { raceResultsService } = useServices();
-
-  return useQuery({
-    queryKey: ['raceWithSOF', raceId],
-    queryFn: () => raceResultsService.getWithSOF(raceId),
-    enabled: !!raceId,
-  });
-}
-
-export function useRacesTotal() {
-  const { raceService } = useServices();
-
-  return useQuery({
-    queryKey: ['racesTotal'],
-    queryFn: () => raceService.getRacesTotal(),
-  });
-}
-
-export function useRegisterForRace() {
-  const { raceService } = useServices();
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: ({ raceId, leagueId, driverId }: {
-      raceId: string;
-      leagueId: string;
-      driverId: string;
-    }) => raceService.registerForRace(raceId, leagueId, driverId),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['racesPageData'] });
-      queryClient.invalidateQueries({ queryKey: ['allRacesPageData'] });
-    },
-  });
-}
-
-export function useWithdrawFromRace() {
-  const { raceService } = useServices();
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: ({ raceId, driverId }: {
-      raceId: string;
-      driverId: string;
-    }) => raceService.withdrawFromRace(raceId, driverId),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['racesPageData'] });
-      queryClient.invalidateQueries({ queryKey: ['allRacesPageData'] });
-    },
-  });
-}
-
-export function useCancelRace() {
-  const { raceService } = useServices();
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (raceId: string) => raceService.cancelRace(raceId),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['racesPageData'] });
-      queryClient.invalidateQueries({ queryKey: ['allRacesPageData'] });
-    },
-  });
-}
-
-export function useCompleteRace() {
-  const { raceService } = useServices();
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (raceId: string) => raceService.completeRace(raceId),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['racesPageData'] });
-      queryClient.invalidateQueries({ queryKey: ['allRacesPageData'] });
-    },
-  });
-}
-
-export function useReopenRace() {
-  const { raceService } = useServices();
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (raceId: string) => raceService.reopenRace(raceId),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['racesPageData'] });
-      queryClient.invalidateQueries({ queryKey: ['allRacesPageData'] });
-    },
-  });
-}

apps/website/hooks/useRaceStewardingService.ts

@@ -1,12 +0,0 @@
-import { useQuery } from '@tanstack/react-query';
-import { useServices } from '@/lib/services/ServiceProvider';
-
-export function useRaceStewardingData(raceId: string, driverId: string) {
-  const { raceStewardingService } = useServices();
-
-  return useQuery({
-    queryKey: ['raceStewardingData', raceId, driverId],
-    queryFn: () => raceStewardingService.getRaceStewardingData(raceId, driverId),
-    enabled: !!raceId && !!driverId,
-  });
-}

apps/website/hooks/useTeamService.ts

@@ -1,11 +0,0 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { useServices } from '@/lib/services/ServiceProvider';
-
-export function useAllTeams() {
-  const { teamService } = useServices();
-
-  return useQuery({
-    queryKey: ['allTeams'],
-    queryFn: () => teamService.getAllTeams(),
-  });
-}