moar fixes + unit test review of routes

src/hooks/useProfileAddress.ts

@@ -0,0 +1,132 @@
+// src/hooks/useProfileAddress.ts
+import { useState, useEffect, useCallback } from 'react';
+import toast from 'react-hot-toast';
+import type { Address, Profile } from '../types';
+import { useApi } from './useApi';
+import * as apiClient from '../services/apiClient';
+import { logger } from '../services/logger.client';
+import { useDebounce } from './useDebounce';
+
+const geocodeWrapper = (address: string, signal?: AbortSignal) => apiClient.geocodeAddress(address, { signal });
+const fetchAddressWrapper = (id: number, signal?: AbortSignal) => apiClient.getUserAddress(id, { signal });
+
+/**
+ * A custom hook to manage a user's profile address, including fetching,
+ * updating, and automatic/manual geocoding.
+ * @param profile The user's profile object.
+ * @param isOpen Whether the parent component (e.g., a modal) is open. This is used to reset state.
+ * @returns An object with address state and handler functions.
+ */
+export const useProfileAddress = (profile: Profile | null, isOpen: boolean) => {
+  const [address, setAddress] = useState<Partial<Address>>({});
+  const [initialAddress, setInitialAddress] = useState<Partial<Address>>({});
+
+  const { execute: geocode, loading: isGeocoding } = useApi<{ lat: number; lng: number }, [string]>(geocodeWrapper);
+  const { execute: fetchAddress } = useApi<Address, [number]>(fetchAddressWrapper);
+
+  const handleAddressFetch = useCallback(async (addressId: number) => {
+    logger.debug(`[useProfileAddress] Starting fetch for addressId: ${addressId}`);
+    const fetchedAddress = await fetchAddress(addressId);
+    if (fetchedAddress) {
+      logger.debug('[useProfileAddress] Successfully fetched address:', fetchedAddress);
+      setAddress(fetchedAddress);
+      setInitialAddress(fetchedAddress);
+    } else {
+      logger.warn(`[useProfileAddress] Fetch returned null or undefined for addressId: ${addressId}.`);
+    }
+  }, [fetchAddress]);
+
+  // Effect to fetch or reset address based on profile and modal state
+  useEffect(() => {
+    if (isOpen && profile) {
+      if (profile.address_id) {
+        logger.debug(`[useProfileAddress] Profile has address_id: ${profile.address_id}. Calling handleAddressFetch.`);
+        handleAddressFetch(profile.address_id);
+      } else {
+        logger.debug('[useProfileAddress] Profile has no address_id. Resetting address form.');
+        setAddress({});
+        setInitialAddress({});
+      }
+    } else {
+        logger.debug('[useProfileAddress] Modal is closed or profile is null. Resetting address state.');
+        setAddress({});
+        setInitialAddress({});
+    }
+  }, [isOpen, profile, handleAddressFetch]);
+
+  const handleAddressChange = (field: keyof Address, value: string) => {
+    setAddress(prev => ({ ...prev, [field]: value }));
+  };
+
+  const handleManualGeocode = async () => {
+    const addressString = [
+      address.address_line_1,
+      address.city,
+      address.province_state,
+      address.postal_code,
+      address.country,
+    ].filter(Boolean).join(', ');
+
+    if (!addressString) {
+      toast.error('Please fill in the address fields before geocoding.');
+      return;
+    }
+
+    const result = await geocode(addressString);
+    if (result) {
+      const { lat, lng } = result;
+      setAddress(prev => ({ ...prev, latitude: lat, longitude: lng }));
+      toast.success('Address re-geocoded successfully!');
+    }
+  };
+
+  // --- Automatic Geocoding Logic ---
+  const debouncedAddress = useDebounce(address, 1500);
+
+  useEffect(() => {
+    const handleAutoGeocode = async () => {
+      logger.debug('[useProfileAddress] Auto-geocode effect triggered by debouncedAddress change');
+      
+      // Prevent geocoding on initial load if the address hasn't been changed by the user.
+      if (JSON.stringify(debouncedAddress) === JSON.stringify(initialAddress)) {
+        logger.debug('[useProfileAddress] Skipping auto-geocode: address is unchanged from initial load.');
+        return;
+      }
+
+      const addressString = [
+        debouncedAddress.address_line_1,
+        debouncedAddress.city,
+        debouncedAddress.province_state,
+        debouncedAddress.postal_code,
+        debouncedAddress.country,
+      ].filter(Boolean).join(', ');
+
+      logger.debug(`[useProfileAddress] addressString generated for auto-geocode: "${addressString}"`);
+
+      // Don't geocode an empty address or if we already have coordinates.
+      if (!addressString || (debouncedAddress.latitude && debouncedAddress.longitude)) {
+        logger.debug('[useProfileAddress] Skipping auto-geocode: empty string or coordinates already exist');
+        return;
+      }
+
+      logger.debug('[useProfileAddress] Calling auto-geocode API...');
+      const result = await geocode(addressString);
+      if (result) {
+        logger.debug('[useProfileAddress] Auto-geocode API returned result:', result);
+        const { lat, lng } = result;
+        setAddress(prev => ({ ...prev, latitude: lat, longitude: lng }));
+        toast.success('Address geocoded successfully!');
+      }
+    };
+
+    handleAutoGeocode();
+  }, [debouncedAddress, initialAddress, geocode]);
+
+  return {
+    address,
+    initialAddress,
+    isGeocoding,
+    handleAddressChange,
+    handleManualGeocode,
+  };
+};