hey-pharmacist-ecommerce 1.0.5 → 1.0.6

package/src/providers/CartProvider.tsx

@@ -1,15 +1,16 @@
 'use client';
 
 import React, { createContext, useContext, useState, useEffect, useCallback } from 'react';
-import { Cart, CartItem } from '@/lib/types';
-import { cartApi } from '@/lib/api/cart';
 import { useAuth } from './AuthProvider';
 import { toast } from 'sonner';
+import { CartResponseDto } from '@/lib/Apis/models';
+import { CartApi } from '@/lib/Apis';
+import { getApiConfiguration } from '@/lib/api-adapter';
 
 interface CartContextValue {
-  cart: Cart | null;
+  cart: CartResponseDto | null;
   isLoading: boolean;
-  addToCart: (productId: string, quantity?: number) => Promise<void>;
+  addToCart: (productId: string, quantity?: number, variantId?: string) => Promise<void>;
   updateQuantity: (productId: string, quantity: number) => Promise<void>;
   removeFromCart: (productId: string) => Promise<void>;
   clearCart: () => Promise<void>;
@@ -31,7 +32,7 @@ interface CartProviderProps {
 }
 
 export function CartProvider({ children }: CartProviderProps) {
-  const [cart, setCart] = useState<Cart | null>(null);
+  const [cart, setCart] = useState<CartResponseDto | null>(null);
   const [isLoading, setIsLoading] = useState(false);
   const { isAuthenticated } = useAuth();
 
@@ -42,10 +43,8 @@ export function CartProvider({ children }: CartProviderProps) {
     }
 
     try {
-      const response = await cartApi.getCart();
-      if (response.success) {
-        setCart(response.data);
-      }
+      const response = await new CartApi(getApiConfiguration()).getUserCart();
+      setCart(response.data);
     } catch (error) {
       console.error('Failed to fetch cart:', error);
     }
@@ -55,14 +54,12 @@ export function CartProvider({ children }: CartProviderProps) {
     refreshCart();
   }, [refreshCart]);
 
-  const addToCart = async (productId: string, quantity: number = 1) => {
+  const addToCart = async (productId: string, quantity: number = 1, variantId?: string) => {
     setIsLoading(true);
     try {
-      const response = await cartApi.addToCart(productId, quantity);
-      if (response.success) {
-        setCart(response.data);
-        toast.success('Added to cart!');
-      }
+      const response = await new CartApi(getApiConfiguration()).handleUserCart({ items: [{ productVariantId: variantId || productId, quantity }] });
+      setCart(response.data);
+      toast.success('Added to cart!');
     } catch (error: any) {
       toast.error(error.response?.data?.message || 'Failed to add to cart');
       throw error;
@@ -74,10 +71,8 @@ export function CartProvider({ children }: CartProviderProps) {
   const updateQuantity = async (productId: string, quantity: number) => {
     setIsLoading(true);
     try {
-      const response = await cartApi.updateCartItem(productId, quantity);
-      if (response.success) {
-        setCart(response.data);
-      }
+      const response = await new CartApi(getApiConfiguration()).handleUserCart({ items: [{ productVariantId: productId, quantity }] });
+      setCart(response.data);
     } catch (error: any) {
       toast.error(error.response?.data?.message || 'Failed to update cart');
       throw error;
@@ -89,11 +84,8 @@ export function CartProvider({ children }: CartProviderProps) {
   const removeFromCart = async (productId: string) => {
     setIsLoading(true);
     try {
-      const response = await cartApi.removeFromCart(productId);
-      if (response.success) {
-        setCart(response.data);
-        toast.success('Removed from cart');
-      }
+      const response = await new CartApi(getApiConfiguration()).handleUserCart({ items: [{ productVariantId: productId, quantity: 0 }] });
+      setCart(response.data);
     } catch (error: any) {
       toast.error(error.response?.data?.message || 'Failed to remove from cart');
       throw error;
@@ -105,9 +97,8 @@ export function CartProvider({ children }: CartProviderProps) {
   const clearCart = async () => {
     setIsLoading(true);
     try {
-      await cartApi.clearCart();
-      setCart({ items: [], total: 0, itemCount: 0 });
-      toast.success('Cart cleared');
+      const response = await new CartApi(getApiConfiguration()).clearCart();
+      setCart(null);
     } catch (error: any) {
       toast.error(error.response?.data?.message || 'Failed to clear cart');
       throw error;
@@ -115,7 +106,6 @@ export function CartProvider({ children }: CartProviderProps) {
       setIsLoading(false);
     }
   };
-
   const value: CartContextValue = {
     cart,
     isLoading,

package/src/providers/EcommerceProvider.tsx

@@ -7,6 +7,8 @@ import { AuthProvider } from './AuthProvider';
 import { CartProvider } from './CartProvider';
 import { initializeApiAdapter } from '@/lib/api-adapter';
 import { Toaster } from 'sonner';
+import { QueryClientProvider } from '@tanstack/react-query';
+import { QueryClient } from '@tanstack/react-query';
 
 interface EcommerceProviderProps {
   config: EcommerceConfig;
@@ -20,7 +22,11 @@ export function EcommerceProvider({ config, children }: EcommerceProviderProps)
     initializeApiAdapter(config);
   }, [config]);
 
+  const [client] = React.useState(
+    new QueryClient({ defaultOptions: { queries: { staleTime: 5000 } } })
+  );
   return (
+    <QueryClientProvider client={client}>
     <ThemeProvider config={config}>
       <AuthProvider>
         <CartProvider>
@@ -29,6 +35,7 @@ export function EcommerceProvider({ config, children }: EcommerceProviderProps)
         </CartProvider>
       </AuthProvider>
     </ThemeProvider>
+    </QueryClientProvider>
   );
 }
 

package/src/providers/FavoritesProvider.tsx

@@ -0,0 +1,86 @@
+'use client';
+
+import { ExtendedProductDTO } from '@/lib/Apis';
+import React, { createContext, useContext, useState, useEffect, ReactNode } from 'react';
+import { toast } from 'sonner';
+
+interface FavoritesContextType {
+  favorites: string[];
+  isFavorite: (productId: string) => boolean;
+  toggleFavorite: (product: ExtendedProductDTO) => void;
+  addToFavorites: (product: ExtendedProductDTO) => void;
+  removeFromFavorites: (productId: string) => void;
+}
+
+const FavoritesContext = createContext<FavoritesContextType | undefined>(undefined);
+
+export function FavoritesProvider({ children }: { children: ReactNode }) {
+  const [favorites, setFavorites] = useState<string[]>([]);
+  const [isClient, setIsClient] = useState(false);
+
+  // Initialize state on client-side to avoid hydration issues
+  useEffect(() => {
+    setIsClient(true);
+    const savedFavorites = localStorage?.getItem('favorites');
+    if (savedFavorites) {
+      try {
+        setFavorites(JSON.parse(savedFavorites));
+      } catch (error) {
+        console.error('Failed to parse favorites from localStorage', error);
+      }
+    }
+  }, []);
+
+  // Save to localStorage whenever favorites change
+  useEffect(() => {
+    if (isClient) {
+      localStorage.setItem('favorites', JSON.stringify(favorites));
+    }
+  }, [favorites, isClient]);
+
+  const isFavorite = (productId: string) => {
+    return favorites.includes(productId);
+  };
+
+  const addToFavorites = (product: ExtendedProductDTO) => {
+    if (!favorites.includes(product.id)) {
+      setFavorites(prev => [...prev, product.id]);
+      toast.success(`${product.name} added to favorites`);
+    }
+  };
+
+  const removeFromFavorites = (productId: string) => {
+    setFavorites(prev => prev.filter(id => id !== productId));
+    toast.info('Removed from favorites');
+  };
+
+  const toggleFavorite = (product: ExtendedProductDTO) => {
+    if (isFavorite(product.id)) {
+      removeFromFavorites(product.id);
+    } else {
+      addToFavorites(product);
+    }
+  };
+
+  return (
+    <FavoritesContext.Provider 
+      value={{ 
+        favorites, 
+        isFavorite, 
+        toggleFavorite, 
+        addToFavorites, 
+        removeFromFavorites 
+      }}
+    >
+      {children}
+    </FavoritesContext.Provider>
+  );
+}
+
+export function useFavorites() {
+  const context = useContext(FavoritesContext);
+  if (context === undefined) {
+    throw new Error('useFavorites must be used within a FavoritesProvider');
+  }
+  return context;
+}

package/src/providers/ThemeProvider.tsx

@@ -2,7 +2,7 @@
 
 import React, { createContext, useContext, useEffect } from 'react';
 import { EcommerceConfig } from '@/lib/types';
-import { generateColorShades } from '@/lib/utils/colors';
+import { generateColorShades, hexToRgb } from '@/lib/utils/colors';
 
 interface ThemeContextValue {
   config: EcommerceConfig;
@@ -46,6 +46,21 @@ export function ThemeProvider({ config, children }: ThemeProviderProps) {
     Object.entries(accentShades).forEach(([shade, rgb]) => {
       root.style.setProperty(`--color-accent-${shade}`, rgb);
     });
+
+    // Header gradient variables (rgb triplets)
+    if (config.headerGradient) {
+      const [fr, fg, fb] = hexToRgb(config.headerGradient.from);
+      const [vr, vg, vb] = hexToRgb(config.headerGradient.via);
+      const [tr, tg, tb] = hexToRgb(config.headerGradient.to);
+      root.style.setProperty(`--header-from`, `${fr} ${fg} ${fb}`);
+      root.style.setProperty(`--header-via`, `${vr} ${vg} ${vb}`);
+      root.style.setProperty(`--header-to`, `${tr} ${tg} ${tb}`);
+    } else {
+      // Fallback to theme shades matching existing design
+      root.style.setProperty(`--header-from`, primaryShades[700]);
+      root.style.setProperty(`--header-via`, primaryShades[600]);
+      root.style.setProperty(`--header-to`, secondaryShades[600]);
+    }
   }, [config.colors]);
 
   return (

package/src/providers/WishlistProvider.tsx

@@ -0,0 +1,174 @@
+'use client';
+
+import React, { createContext, useContext, useState, useEffect, ReactNode, useCallback } from 'react';
+import { WishlistApi } from '@/lib/Apis/apis/wishlist-api';
+import { AXIOS_CONFIG } from '@/lib/Apis/wrapper';
+import { useAuth } from './AuthProvider';
+import { toast } from 'sonner';
+import { useMemo } from 'react';
+import { Wishlist } from '@/lib/Apis';
+import { Product } from '@/lib/Apis/models';
+
+
+interface WishlistContextType extends Wishlist {
+  addToWishlist: (product: Product) => Promise<void>;
+  removeFromWishlist: (productId: string) => Promise<void>;
+  isInWishlist: (productId: string) => boolean;
+  getWishlistCount: () => number;
+  refreshWishlist: () => Promise<void>;
+  clearWishlist: () => Promise<void>;
+}
+
+const WishlistContext = createContext<WishlistContextType | undefined>(undefined);
+
+export function WishlistProvider({ children }: { children: ReactNode }) {
+  const [state, setState] = useState<Wishlist>({
+    _id: '',
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    userId: '',
+    products: [],
+  } as unknown as Wishlist);
+
+  const { isAuthenticated } = useAuth() || {};
+  const wishlistApi = useMemo(() => new WishlistApi(AXIOS_CONFIG), []);
+
+  const fetchWishlist = useCallback(async () => {
+    if (!isAuthenticated) {
+      setState(prev => ({
+        ...prev,
+        isLoading: false,
+        products: [],
+      }));
+      return;
+    }
+
+    setState(prev => ({ ...prev, isLoading: true, error: null }));
+
+    try {
+      const response = await wishlistApi.getWishlist();
+      const responseData = response?.data;
+
+      setState({
+        _id: responseData._id,
+        createdAt: responseData.createdAt,
+        updatedAt: responseData.updatedAt,
+        userId: responseData.userId,
+        products: responseData.products,
+      } as unknown as Wishlist);
+    } catch (error) {
+      console.error('Error fetching wishlist:', error);
+      setState(prev => ({
+        ...prev,
+        isLoading: false,
+        error: error instanceof Error ? error.message : 'Failed to load wishlist',
+      }));
+    }
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isAuthenticated]);
+
+
+  useEffect(() => {
+    fetchWishlist();
+  }, [fetchWishlist]);
+
+  const addToWishlist = async (product: Product) => {
+    if (!isAuthenticated) {
+      toast.error('Please sign in to add items to your wishlist');
+      return;
+    }
+
+    try {
+      // First check if the item is already in the wishlist
+      if (isInWishlist(product?._id || '')) {
+        toast.info('This item is already in your wishlist');
+        return;
+      }
+
+      // Make the API call
+      await wishlistApi.addToWishlist(product?._id || '');
+
+      // Instead of updating state directly, refresh the entire wishlist from the server
+      // This ensures we're in sync with the server and prevents duplicates
+      await fetchWishlist();
+
+      toast.success('Added to wishlist');
+    } catch (error) {
+      console.error('Error adding to wishlist:', error);
+      toast.error('Failed to add to wishlist');
+      throw error;
+    }
+  };
+
+  const removeFromWishlist = async (productId: string) => {
+    try {
+      await wishlistApi.removeFromWishlist(productId);
+
+      setState(prev => {
+        const newProducts = prev.products.filter((product: any) => product?._id !== productId);
+        return {
+          ...prev,
+          products: newProducts,
+        };
+
+      });
+
+      toast.success('Removed from wishlist');
+    } catch (error) {
+      console.error('Error removing from wishlist:', error);
+      toast.error('Failed to remove from wishlist');
+      throw error;
+    }
+  };
+
+  const clearWishlist = async () => {
+    try {
+      await wishlistApi.clearWishlist();
+      setState(prev => ({
+        ...prev,
+        products: [],
+      }));
+      toast.success('Wishlist cleared');
+    } catch (error) {
+      console.error('Error clearing wishlist:', error);
+      toast.error('Failed to clear wishlist');
+      throw error;
+    }
+  };
+
+  const isInWishlist = (productId: string): boolean => {
+    return state.products.some((product: any) => product?._id === productId);
+  };
+
+  const getWishlistCount = (): number => {
+    return state.products.length;
+  };
+
+  const refreshWishlist = async () => {
+    await fetchWishlist();
+  };
+
+  return (
+    <WishlistContext.Provider
+      value={{
+        ...state,
+        addToWishlist,
+        removeFromWishlist,
+        isInWishlist,
+        getWishlistCount,
+        refreshWishlist,
+        clearWishlist,
+      }}
+    >
+      {children}
+    </WishlistContext.Provider>
+  );
+}
+
+export const useWishlist = (): WishlistContextType => {
+  const context = useContext(WishlistContext);
+  if (context === undefined) {
+    throw new Error('useWishlist must be used within a WishlistProvider');
+  }
+  return context;
+};