Removes Wild Cloud cruft.

web/src/hooks/__tests__/useStatus.test.ts

@@ -3,12 +3,12 @@ import { renderHook, waitFor } from '@testing-library/react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import React from 'react';
 import { useStatus } from '../useStatus';
-import { apiService } from '../../services/api-legacy';
+import { apiClient } from '../../services/api/client';
 
-// Mock the API service
-vi.mock('../../services/api-legacy', () => ({
-  apiService: {
-    getStatus: vi.fn(),
+// Mock the API client
+vi.mock('../../services/api/client', () => ({
+  apiClient: {
+    get: vi.fn(),
   },
 }));
 
@@ -21,7 +21,7 @@ const createWrapper = () => {
       },
     },
   });
-  
+
   return ({ children }: { children: React.ReactNode }) => (
     React.createElement(QueryClientProvider, { client: queryClient }, children)
   );
@@ -40,7 +40,7 @@ describe('useStatus', () => {
       timestamp: '2024-01-01T00:00:00Z',
     };
 
-    (apiService.getStatus as ReturnType<typeof vi.fn>).mockResolvedValue(mockStatus);
+    (apiClient.get as ReturnType<typeof vi.fn>).mockResolvedValue(mockStatus);
 
     const { result } = renderHook(() => useStatus(), {
       wrapper: createWrapper(),
@@ -55,12 +55,12 @@ describe('useStatus', () => {
 
     expect(result.current.data).toEqual(mockStatus);
     expect(result.current.error).toBeNull();
-    expect(apiService.getStatus).toHaveBeenCalledTimes(1);
+    expect(apiClient.get).toHaveBeenCalledTimes(1);
   });
 
   it('should handle error when fetching status fails', async () => {
     const mockError = new Error('Network error');
-    (apiService.getStatus as ReturnType<typeof vi.fn>).mockRejectedValue(mockError);
+    (apiClient.get as ReturnType<typeof vi.fn>).mockRejectedValue(mockError);
 
     const { result } = renderHook(() => useStatus(), {
       wrapper: createWrapper(),
@@ -82,7 +82,7 @@ describe('useStatus', () => {
       timestamp: '2024-01-01T00:00:00Z',
     };
 
-    (apiService.getStatus as ReturnType<typeof vi.fn>).mockResolvedValue(mockStatus);
+    (apiClient.get as ReturnType<typeof vi.fn>).mockResolvedValue(mockStatus);
 
     const { result } = renderHook(() => useStatus(), {
       wrapper: createWrapper(),
@@ -92,13 +92,13 @@ describe('useStatus', () => {
       expect(result.current.isLoading).toBe(false);
     });
 
-    expect(apiService.getStatus).toHaveBeenCalledTimes(1);
+    expect(apiClient.get).toHaveBeenCalledTimes(1);
 
     // Trigger refetch
     result.current.refetch();
 
     await waitFor(() => {
-      expect(apiService.getStatus).toHaveBeenCalledTimes(2);
+      expect(apiClient.get).toHaveBeenCalledTimes(2);
     });
   });
-});
+});

web/src/hooks/useDnsmasq.ts

@@ -1,63 +1,58 @@
 import { useMutation, useQuery } from '@tanstack/react-query';
-import { apiService } from '../services/api-legacy';
+import { apiClient } from '../services/api/client';
 import type { DnsmasqStatus, DnsmasqConfigResponse, StatusResponse } from '../types';
 
 export const useDnsmasq = () => {
-  // Query for status
   const statusQuery = useQuery<DnsmasqStatus>({
     queryKey: ['dnsmasq', 'status'],
-    queryFn: () => apiService.getDnsmasqStatus(),
+    queryFn: () => apiClient.get<DnsmasqStatus>('/api/v1/dnsmasq/status'),
     refetchInterval: 30000,
     staleTime: 10000,
   });
 
-  // Query for config
   const configQuery = useQuery<DnsmasqConfigResponse>({
     queryKey: ['dnsmasq', 'config'],
-    queryFn: () => apiService.getDnsmasqConfig(),
-    enabled: false, // Only fetch when explicitly called
+    queryFn: () => apiClient.get<DnsmasqConfigResponse>('/api/v1/dnsmasq/config'),
+    enabled: false,
   });
 
-  // Mutation for generating config (with optional overwrite)
   const generateMutation = useMutation<DnsmasqConfigResponse, Error, boolean>({
-    mutationFn: (overwrite = false) => apiService.generateDnsmasqConfig(overwrite),
+    mutationFn: (overwrite = false) => {
+      const url = overwrite ? '/api/v1/dnsmasq/generate?overwrite=true' : '/api/v1/dnsmasq/generate';
+      return apiClient.post<DnsmasqConfigResponse>(url);
+    },
     onSuccess: () => {
       statusQuery.refetch();
       configQuery.refetch();
     },
   });
 
-  // Mutation for restarting service
   const restartMutation = useMutation<StatusResponse>({
-    mutationFn: () => apiService.restartDnsmasq(),
+    mutationFn: () => apiClient.post<StatusResponse>('/api/v1/dnsmasq/restart'),
     onSuccess: () => {
       statusQuery.refetch();
     },
   });
 
   return {
-    // Status
     status: statusQuery.data,
     isLoadingStatus: statusQuery.isLoading,
     statusError: statusQuery.error,
     refetchStatus: statusQuery.refetch,
 
-    // Config
     config: configQuery.data,
     isLoadingConfig: configQuery.isLoading,
     configError: configQuery.error,
     fetchConfig: configQuery.refetch,
 
-    // Generate
     generateConfig: generateMutation.mutate,
     generateData: generateMutation.data,
     isGenerating: generateMutation.isPending,
     generateError: generateMutation.error,
 
-    // Restart
     restart: restartMutation.mutate,
     restartData: restartMutation.data,
     isRestarting: restartMutation.isPending,
     restartError: restartMutation.error,
   };
-};
+};

web/src/hooks/useHealth.ts

@@ -1,5 +1,5 @@
 import { useMutation } from '@tanstack/react-query';
-import { apiService } from '../services/api-legacy';
+import { apiClient } from '../services/api/client';
 
 interface HealthResponse {
   service: string;
@@ -8,6 +8,6 @@ interface HealthResponse {
 
 export const useHealth = () => {
   return useMutation<HealthResponse>({
-    mutationFn: apiService.getHealth,
+    mutationFn: () => apiClient.get<HealthResponse>('/api/v1/health'),
   });
-};
+};

web/src/hooks/useStatus.ts

@@ -1,11 +1,11 @@
 import { useQuery } from '@tanstack/react-query';
-import { apiService } from '../services/api-legacy';
+import { apiClient } from '../services/api/client';
 import type { Status } from '../types';
 
 export const useStatus = () => {
   return useQuery<Status>({
     queryKey: ['status'],
-    queryFn: apiService.getStatus,
-    refetchInterval: 30000, // Refetch every 30 seconds
+    queryFn: () => apiClient.get<Status>('/api/status'),
+    refetchInterval: 30000,
   });
-};
+};