@jmruthers/pace-core 0.6.9 → 0.6.11

package/src/hooks/useAddressAutocomplete.test.ts

@@ -1,29 +1,49 @@
 /**
- * @file Address Autocomplete Hook Tests
+ * @file useAddressAutocomplete Hook Tests
  * @package @jmruthers/pace-core
- * @module Hooks/__tests__
+ * @module Hooks
  * @since 0.1.0
+ *
+ * Comprehensive tests for the useAddressAutocomplete hook covering autocomplete suggestions,
+ * address selection, caching, error handling, and edge cases.
  */
 
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { renderHook, waitFor } from '@testing-library/react';
 import { useAddressAutocomplete } from './useAddressAutocomplete';
-import * as googlePlacesUtils from '../utils/google-places';
-
-// Mock the Google Places utilities
-vi.mock('../utils/google-places', () => ({
-  fetchPlaceAutocomplete: vi.fn(),
-  fetchPlaceDetails: vi.fn(),
-  createAddressFromPlaceResult: vi.fn(),
-  getAddressByPlaceId: vi.fn(),
+
+// Following testing standards: configure timeouts to prevent hanging
+const TEST_TIMEOUT = 10000; // 10 seconds per test
+
+// Mock the Google Places utilities - mock individual file since barrel was removed
+const mockFetchPlaceAutocomplete = vi.hoisted(() => vi.fn());
+const mockFetchPlaceDetails = vi.hoisted(() => vi.fn());
+const mockCreateAddressFromPlaceResult = vi.hoisted(() => vi.fn());
+const mockGetAddressByPlaceId = vi.hoisted(() => vi.fn());
+
+vi.mock('../utils/google-places/googlePlacesUtils', () => ({
+  fetchPlaceAutocomplete: mockFetchPlaceAutocomplete,
+  fetchPlaceDetails: mockFetchPlaceDetails,
+  createAddressFromPlaceResult: mockCreateAddressFromPlaceResult,
+  getAddressByPlaceId: mockGetAddressByPlaceId,
 }));
 
-// Mock useQueryCache
+// Mock useQueryCache with stable function reference to prevent infinite re-renders
+// This is critical: the function must be stable across renders to prevent infinite useEffect loops
+// The real useQueryCache returns a stable getCachedQuery via useCallback, so our mock must too
+const createStableGetCachedQuery = () => {
+  const stableFn = async <T,>(_table: string, _filterKey: string, _filterValue: string, fetchFn: () => Promise<T>) => {
+    return fetchFn();
+  };
+  return stableFn;
+};
+
+// Create the stable function once outside the mock factory
+const stableGetCachedQuery = createStableGetCachedQuery();
+
 vi.mock('./useQueryCache', () => ({
   useQueryCache: () => ({
-    getCachedQuery: async <T,>(_table: string, _filterKey: string, _filterValue: string, fetchFn: () => Promise<T>) => {
-      return fetchFn();
-    },
+    getCachedQuery: stableGetCachedQuery,
   }),
 }));
 
@@ -45,7 +65,7 @@ describe('useAddressAutocomplete', () => {
   });
 
   describe('Initial state', () => {
-    it('returns initial state with empty suggestions', { timeout: 5000 }, () => {
+    it('returns initial state with empty suggestions', { timeout: TEST_TIMEOUT }, () => {
       const { result } = renderHook(() => useAddressAutocomplete(mockApiKey, ''));
 
       expect(result.current.suggestions).toEqual([]);
@@ -55,7 +75,7 @@ describe('useAddressAutocomplete', () => {
   });
 
   describe('Autocomplete suggestions', () => {
-    it('fetches suggestions when input value changes', { timeout: 5000 }, async () => {
+    it('fetches suggestions when input value changes', { timeout: TEST_TIMEOUT }, async () => {
       const mockPredictions = [
         {
           description: '123 Main St, Melbourne VIC, Australia',
@@ -67,7 +87,7 @@ describe('useAddressAutocomplete', () => {
         },
       ];
 
-      vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValueOnce(mockPredictions);
+      mockFetchPlaceAutocomplete.mockResolvedValueOnce({ ok: true, data: mockPredictions });
 
       const { result } = renderHook(() =>
         useAddressAutocomplete(mockApiKey, '123 Main', { debounceDelay: 0 })
@@ -83,8 +103,8 @@ describe('useAddressAutocomplete', () => {
       expect(result.current.suggestions[0].place_id).toBe('ChIJ123');
     });
 
-    it('debounces input value', { timeout: 5000 }, async () => {
-      vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValue([]);
+    it('debounces input value', { timeout: TEST_TIMEOUT }, async () => {
+      mockFetchPlaceAutocomplete.mockResolvedValue({ ok: true, data: [] });
 
       // Since we're mocking useDebounce to return immediately, this test verifies
       // that the hook still works correctly with rapid input changes
@@ -101,19 +121,20 @@ describe('useAddressAutocomplete', () => {
       // Wait for the last call
       await waitFor(
         () => {
-          expect(googlePlacesUtils.fetchPlaceAutocomplete).toHaveBeenCalled();
+          expect(mockFetchPlaceAutocomplete).toHaveBeenCalled();
         },
         { timeout: 1000 }
       );
 
       // With mocked debounce, it will be called for each change
-      expect(googlePlacesUtils.fetchPlaceAutocomplete).toHaveBeenCalled();
+      expect(mockFetchPlaceAutocomplete).toHaveBeenCalled();
     });
 
-    it('clears suggestions when input is empty', { timeout: 5000 }, async () => {
-      vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValueOnce([
-        { description: '123 Main St', place_id: 'ChIJ123' },
-      ]);
+    it('clears suggestions when input is empty', { timeout: TEST_TIMEOUT }, async () => {
+      mockFetchPlaceAutocomplete.mockResolvedValueOnce({
+        ok: true,
+        data: [{ description: '123 Main St', place_id: 'ChIJ123', structured_formatting: { main_text: '123 Main St', secondary_text: '' } }],
+      });
 
       const { result, rerender } = renderHook(
         ({ inputValue }) => useAddressAutocomplete(mockApiKey, inputValue, { debounceDelay: 0 }),
@@ -139,9 +160,9 @@ describe('useAddressAutocomplete', () => {
       );
     });
 
-    it('handles API errors', { timeout: 5000 }, async () => {
+    it('handles API errors', { timeout: TEST_TIMEOUT }, async () => {
       const error = new Error('API request denied');
-      vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockRejectedValueOnce(error);
+      mockFetchPlaceAutocomplete.mockResolvedValueOnce({ ok: false, error: { code: 'AUTOCOMPLETE_ERROR', message: error.message } });
 
       const { result } = renderHook(() =>
         useAddressAutocomplete(mockApiKey, '123 Main', { debounceDelay: 0 })
@@ -160,7 +181,7 @@ describe('useAddressAutocomplete', () => {
   });
 
   describe('Address selection', () => {
-    it('selects address by place_id', { timeout: 5000 }, async () => {
+    it('selects address by place_id', { timeout: TEST_TIMEOUT }, async () => {
       const mockPlaceDetails = {
         place_id: 'ChIJ123',
         formatted_address: '123 Main St, Melbourne VIC 3000, Australia',
@@ -181,8 +202,8 @@ describe('useAddressAutocomplete', () => {
         lng: 144.9631,
       };
 
-      vi.mocked(googlePlacesUtils.fetchPlaceDetails).mockResolvedValueOnce(mockPlaceDetails);
-      vi.mocked(googlePlacesUtils.createAddressFromPlaceResult).mockReturnValueOnce(mockParsedAddress);
+      mockFetchPlaceDetails.mockResolvedValueOnce({ ok: true, data: mockPlaceDetails });
+      mockCreateAddressFromPlaceResult.mockReturnValueOnce(mockParsedAddress);
 
       const { result } = renderHook(() => useAddressAutocomplete(mockApiKey, ''));
 
@@ -190,11 +211,11 @@ describe('useAddressAutocomplete', () => {
 
       expect(address).not.toBeNull();
       expect(address?.place_id).toBe('ChIJ123');
-      expect(googlePlacesUtils.fetchPlaceDetails).toHaveBeenCalledWith('ChIJ123', mockApiKey);
+      expect(mockFetchPlaceDetails).toHaveBeenCalledWith('ChIJ123', mockApiKey);
     });
 
-    it('returns null when place_id is invalid', async () => {
-      vi.mocked(googlePlacesUtils.fetchPlaceDetails).mockRejectedValueOnce(new Error('Place not found'));
+    it('returns null when place_id is invalid', { timeout: TEST_TIMEOUT }, async () => {
+      mockFetchPlaceDetails.mockResolvedValueOnce({ ok: false, error: { code: 'NOT_FOUND', message: 'Place not found' } });
 
       const { result } = renderHook(() => useAddressAutocomplete(mockApiKey, ''));
 
@@ -205,7 +226,7 @@ describe('useAddressAutocomplete', () => {
   });
 
   describe('getAddressByPlaceId', () => {
-    it('retrieves address by place_id', { timeout: 5000 }, async () => {
+    it('retrieves address by place_id', { timeout: TEST_TIMEOUT }, async () => {
       const mockAddress = {
         place_id: 'ChIJ123',
         full_address: '123 Main St',
@@ -219,7 +240,7 @@ describe('useAddressAutocomplete', () => {
         lng: null,
       };
 
-      vi.mocked(googlePlacesUtils.getAddressByPlaceId).mockResolvedValueOnce(mockAddress);
+      mockGetAddressByPlaceId.mockResolvedValueOnce({ ok: true, data: mockAddress });
 
       const { result } = renderHook(() => useAddressAutocomplete(mockApiKey, ''));
 
@@ -229,8 +250,8 @@ describe('useAddressAutocomplete', () => {
       expect(address?.place_id).toBe('ChIJ123');
     });
 
-    it('returns null on error', async () => {
-      vi.mocked(googlePlacesUtils.getAddressByPlaceId).mockResolvedValueOnce(null);
+    it('returns null on error', { timeout: TEST_TIMEOUT }, async () => {
+      mockGetAddressByPlaceId.mockResolvedValueOnce({ ok: false, error: { code: 'ERR', message: 'Failed' } });
 
       const { result } = renderHook(() => useAddressAutocomplete(mockApiKey, ''));
 
@@ -241,10 +262,11 @@ describe('useAddressAutocomplete', () => {
   });
 
   describe('clearSuggestions', () => {
-    it('clears suggestions', { timeout: 5000 }, async () => {
-      vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValueOnce([
-        { description: '123 Main St', place_id: 'ChIJ123' },
-      ]);
+    it('clears suggestions', { timeout: TEST_TIMEOUT }, async () => {
+      mockFetchPlaceAutocomplete.mockResolvedValueOnce({
+        ok: true,
+        data: [{ description: '123 Main St', place_id: 'ChIJ123', structured_formatting: { main_text: '123 Main St', secondary_text: '' } }],
+      });
 
       const { result } = renderHook(() =>
         useAddressAutocomplete(mockApiKey, '123 Main', { debounceDelay: 0 })
@@ -272,9 +294,9 @@ describe('useAddressAutocomplete', () => {
   });
 
   describe('Caching', () => {
-    it('uses cache when enabled', async () => {
+    it('uses cache when enabled', { timeout: TEST_TIMEOUT }, async () => {
       const mockPredictions = [{ description: '123 Main St', place_id: 'ChIJ123' }];
-      vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValueOnce(mockPredictions);
+      mockFetchPlaceAutocomplete.mockResolvedValueOnce({ ok: true, data: mockPredictions });
 
       const { result } = renderHook(() =>
         useAddressAutocomplete(mockApiKey, '123 Main', {
@@ -290,12 +312,12 @@ describe('useAddressAutocomplete', () => {
         { timeout: 1000 }
       );
 
-      expect(googlePlacesUtils.fetchPlaceAutocomplete).toHaveBeenCalled();
+      expect(mockFetchPlaceAutocomplete).toHaveBeenCalled();
     });
 
-    it('skips cache when disabled', async () => {
+    it('skips cache when disabled', { timeout: TEST_TIMEOUT }, async () => {
       const mockPredictions = [{ description: '123 Main St', place_id: 'ChIJ123' }];
-      vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValueOnce(mockPredictions);
+      mockFetchPlaceAutocomplete.mockResolvedValueOnce({ ok: true, data: mockPredictions });
 
       const { result } = renderHook(() =>
         useAddressAutocomplete(mockApiKey, '123 Main', {
@@ -311,7 +333,108 @@ describe('useAddressAutocomplete', () => {
         { timeout: 1000 }
       );
 
-      expect(googlePlacesUtils.fetchPlaceAutocomplete).toHaveBeenCalled();
+      expect(mockFetchPlaceAutocomplete).toHaveBeenCalled();
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('handles missing API key', { timeout: TEST_TIMEOUT }, async () => {
+      const { result } = renderHook(() =>
+        useAddressAutocomplete('', '123 Main', { debounceDelay: 0 })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.error).not.toBeNull();
+        },
+        { timeout: 1000 }
+      );
+
+      expect(result.current.error?.message).toBe('Google Places API key is required');
+    });
+
+    it('handles network errors gracefully', { timeout: TEST_TIMEOUT }, async () => {
+      const error = new Error('Network error');
+      mockFetchPlaceAutocomplete.mockResolvedValueOnce({ ok: false, error: { code: 'AUTOCOMPLETE_ERROR', message: error.message } });
+
+      const { result } = renderHook(() =>
+        useAddressAutocomplete(mockApiKey, '123 Main', { debounceDelay: 0 })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.error).not.toBeNull();
+        },
+        { timeout: 1000 }
+      );
+
+      expect(result.current.error?.message).toBe('Network error');
+      expect(result.current.suggestions).toEqual([]);
+    });
+
+    it('handles selectAddress errors gracefully', { timeout: TEST_TIMEOUT }, async () => {
+      mockFetchPlaceDetails.mockResolvedValueOnce({ ok: false, error: { code: 'ERR', message: 'Place not found' } });
+
+      const { result } = renderHook(() => useAddressAutocomplete(mockApiKey, ''));
+
+      const address = await result.current.selectAddress('invalid');
+
+      expect(address).toBeNull();
+      // Error is set but may be cleared by subsequent operations
+      // The important part is that it returns null and doesn't throw
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('handles whitespace-only input', { timeout: TEST_TIMEOUT }, async () => {
+      const { result } = renderHook(() =>
+        useAddressAutocomplete(mockApiKey, '   ', { debounceDelay: 0 })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.suggestions).toEqual([]);
+        },
+        { timeout: 1000 }
+      );
+
+      expect(mockFetchPlaceAutocomplete).not.toHaveBeenCalled();
+    });
+
+    it('handles rapid input changes', { timeout: TEST_TIMEOUT }, async () => {
+      mockFetchPlaceAutocomplete.mockResolvedValue({ ok: true, data: [] });
+
+      const { result, rerender } = renderHook(
+        ({ inputValue }) => useAddressAutocomplete(mockApiKey, inputValue, { debounceDelay: 0 }),
+        { initialProps: { inputValue: '123' } }
+      );
+
+      rerender({ inputValue: '123 M' });
+      rerender({ inputValue: '123 Ma' });
+      rerender({ inputValue: '123 Main' });
+
+      await waitFor(
+        () => {
+          expect(mockFetchPlaceAutocomplete).toHaveBeenCalled();
+        },
+        { timeout: 1000 }
+      );
+    });
+
+    it('handles empty suggestions array', { timeout: TEST_TIMEOUT }, async () => {
+      mockFetchPlaceAutocomplete.mockResolvedValueOnce({ ok: true, data: [] });
+
+      const { result } = renderHook(() =>
+        useAddressAutocomplete(mockApiKey, 'nonexistent', { debounceDelay: 0 })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.suggestions).toEqual([]);
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 1000 }
+      );
     });
   });
 });

package/src/hooks/useAddressAutocomplete.ts

@@ -8,7 +8,7 @@
  * Provides debounced input, caching, and address selection.
  */
 
-import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
+import { useState, useEffect, useCallback, useMemo, type Dispatch, type SetStateAction } from 'react';
 import { useDebounce } from './useDebounce';
 import { useQueryCache } from './useQueryCache';
 import {
@@ -16,12 +16,68 @@ import {
   fetchPlaceDetails,
   createAddressFromPlaceResult,
   getAddressByPlaceId,
-} from '../utils/google-places';
+} from '../utils/google-places/googlePlacesUtils';
 import type {
   GooglePlaceAutocompletePrediction,
   ParsedAddress,
   AutocompleteOptions,
-} from '../utils/google-places';
+} from '../utils/google-places/types';
+
+/** Fetch autocomplete suggestions and update state via setters. Used by useAddressAutocomplete effect. */
+async function fetchSuggestionsForInput(
+  debouncedInput: string,
+  apiKey: string,
+  memoizedAutocompleteOptions: AutocompleteOptions | undefined,
+  cacheEnabled: boolean,
+  cacheTTLAutocomplete: number,
+  getCachedQuery: ReturnType<typeof useQueryCache>['getCachedQuery'],
+  isCancelledRef: { current: boolean },
+  setters: {
+    setSuggestions: Dispatch<SetStateAction<GooglePlaceAutocompletePrediction[]>>;
+    setError: Dispatch<SetStateAction<Error | null>>;
+    setIsLoading: Dispatch<SetStateAction<boolean>>;
+  }
+): Promise<void> {
+  try {
+    let result: Awaited<ReturnType<typeof fetchPlaceAutocomplete>>;
+
+    if (cacheEnabled) {
+      result = await getCachedQuery(
+        'google-places-autocomplete',
+        'query',
+        debouncedInput,
+        async () => {
+          if (isCancelledRef.current) {
+            throw new Error('Request cancelled');
+          }
+          return fetchPlaceAutocomplete(debouncedInput, apiKey, memoizedAutocompleteOptions);
+        },
+        { ttl: cacheTTLAutocomplete, enabled: true }
+      );
+    } else {
+      result = await fetchPlaceAutocomplete(debouncedInput, apiKey, memoizedAutocompleteOptions);
+    }
+
+    if (isCancelledRef.current) return;
+
+    if (!result.ok) {
+      setters.setError(new Error(result.error.message));
+      setters.setSuggestions([]);
+      setters.setIsLoading(false);
+      return;
+    }
+    setters.setSuggestions(result.data);
+    setters.setIsLoading(false);
+  } catch (err) {
+    if (isCancelledRef.current || (err instanceof Error && err.message === 'Request cancelled')) {
+      return;
+    }
+    const error = err instanceof Error ? err : new Error('Failed to fetch autocomplete suggestions');
+    setters.setError(error);
+    setters.setSuggestions([]);
+    setters.setIsLoading(false);
+  }
+}
 
 export interface UseAddressAutocompleteOptions {
   /** Google Places API options */
@@ -92,84 +148,54 @@ export function useAddressAutocomplete(
 
   const debouncedInput = useDebounce(inputValue, debounceDelay);
   const { getCachedQuery } = useQueryCache();
-  const abortControllerRef = useRef<AbortController | null>(null);
 
   // Memoize autocompleteOptions to prevent unnecessary re-renders
-  const memoizedAutocompleteOptions = useMemo(
-    () => autocompleteOptions,
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [JSON.stringify(autocompleteOptions)]
-  );
+  // Use a stable reference by comparing key properties instead of JSON.stringify
+  const memoizedAutocompleteOptions = useMemo(() => {
+    if (!autocompleteOptions) {
+      return undefined;
+    }
+    // Return a new object with only the properties we care about to ensure stability
+    return {
+      components: autocompleteOptions.components,
+      location: autocompleteOptions.location,
+      radius: autocompleteOptions.radius,
+      language: autocompleteOptions.language,
+      types: autocompleteOptions.types,
+    };
+  }, [
+    autocompleteOptions,
+  ]);
 
   // Fetch autocomplete suggestions
   useEffect(() => {
-    // Cancel previous request if still in flight
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort();
-    }
-
-    // Reset state if input is empty
     if (!debouncedInput.trim()) {
       setSuggestions([]);
       setIsLoading(false);
       setError(null);
       return;
     }
-
-    // Don't fetch if no API key
     if (!apiKey) {
       setError(new Error('Google Places API key is required'));
       return;
     }
-
     setIsLoading(true);
     setError(null);
-
-    const fetchSuggestions = async () => {
-      try {
-        let predictions: GooglePlaceAutocompletePrediction[];
-
-        if (cacheEnabled) {
-          // Use cached query with TTL
-          predictions = await getCachedQuery(
-            'google-places-autocomplete',
-            'query',
-            debouncedInput,
-            async () => {
-              return fetchPlaceAutocomplete(debouncedInput, apiKey, memoizedAutocompleteOptions);
-            },
-            { ttl: cacheTTL.autocomplete, enabled: true }
-          );
-        } else {
-          // Direct fetch without cache
-          predictions = await fetchPlaceAutocomplete(debouncedInput, apiKey, memoizedAutocompleteOptions);
-        }
-
-        setSuggestions(predictions);
-        setIsLoading(false);
-      } catch (err) {
-        // Ignore aborted requests
-        if (err instanceof Error && err.name === 'AbortError') {
-          return;
-        }
-
-        const error = err instanceof Error ? err : new Error('Failed to fetch autocomplete suggestions');
-        setError(error);
-        setSuggestions([]);
-        setIsLoading(false);
-      }
-    };
-
-    fetchSuggestions();
-
-    // Cleanup function to cancel in-flight requests
+    const isCancelledRef = { current: false };
+    fetchSuggestionsForInput(
+      debouncedInput,
+      apiKey,
+      memoizedAutocompleteOptions,
+      cacheEnabled,
+      cacheTTL.autocomplete ?? 3600,
+      getCachedQuery,
+      isCancelledRef,
+      { setSuggestions, setError, setIsLoading }
+    );
     return () => {
-      if (abortControllerRef.current) {
-        abortControllerRef.current.abort();
-      }
+      isCancelledRef.current = true;
     };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [debouncedInput, apiKey, cacheEnabled, cacheTTL.autocomplete]);
+  }, [debouncedInput, apiKey, cacheEnabled, cacheTTL.autocomplete, memoizedAutocompleteOptions, getCachedQuery]);
 
   // Select address by place_id
   const selectAddress = useCallback(
@@ -182,25 +208,26 @@ export function useAddressAutocomplete(
       setError(null);
 
       try {
-        let placeDetails;
+        let placeResult: Awaited<ReturnType<typeof fetchPlaceDetails>>;
 
         if (cacheEnabled) {
-          // Use cached query with TTL
-          placeDetails = await getCachedQuery(
+          placeResult = await getCachedQuery(
             'google-places-details',
             'place_id',
             placeId,
-            async () => {
-              return fetchPlaceDetails(placeId, apiKey);
-            },
+            async () => fetchPlaceDetails(placeId, apiKey),
             { ttl: cacheTTL.placeDetails, enabled: true }
           );
         } else {
-          // Direct fetch without cache
-          placeDetails = await fetchPlaceDetails(placeId, apiKey);
+          placeResult = await fetchPlaceDetails(placeId, apiKey);
         }
 
-        const parsedAddress = createAddressFromPlaceResult(placeDetails);
+        if (!placeResult.ok) {
+          setError(new Error(placeResult.error.message));
+          setIsLoading(false);
+          return null;
+        }
+        const parsedAddress = createAddressFromPlaceResult(placeResult.data);
         setIsLoading(false);
         return parsedAddress;
       } catch (err) {
@@ -222,24 +249,25 @@ export function useAddressAutocomplete(
       }
 
       try {
+        let result: Awaited<ReturnType<typeof getAddressByPlaceId>>;
+
         if (cacheEnabled) {
-          // Use cached query with TTL
-          return await getCachedQuery(
+          result = await getCachedQuery(
             'google-places-details',
             'place_id',
             placeId,
-            async () => {
-              const result = await getAddressByPlaceId(placeId, apiKey);
-              if (!result) {
-                throw new Error('Failed to fetch address');
-              }
-              return result;
-            },
+            async () => getAddressByPlaceId(placeId, apiKey),
             { ttl: cacheTTL.placeDetails, enabled: true }
           );
         } else {
-          return await getAddressByPlaceId(placeId, apiKey);
+          result = await getAddressByPlaceId(placeId, apiKey);
+        }
+
+        if (!result.ok) {
+          setError(new Error(result.error.message));
+          return null;
         }
+        return result.data;
       } catch (err) {
         const error = err instanceof Error ? err : new Error('Failed to get address by place_id');
         setError(error);