hey-pharmacist-ecommerce 1.0.0

package/src/lib/api-adapter/products-adapter.ts

@@ -0,0 +1,194 @@
+/**
+ * Products API Adapter
+ * Connects frontend products to real backend products APIs
+ */
+
+import { ProductsApi } from '../Apis/apis/products-api';
+import { CategoriesApi } from '../Apis/apis/categories-api';
+import { getApiConfiguration } from './config';
+import { mapProduct } from './mappers';
+import { Product, ApiResponse, PaginatedResponse, ProductFilters, Category } from '../types';
+
+export const productsAdapter = {
+  /**
+   * Get all products with optional filters and pagination
+   */
+  async getProducts(
+    filters?: ProductFilters,
+    page: number = 1,
+    limit: number = 20
+  ): Promise<PaginatedResponse<Product>> {
+    try {
+      const productsApi = new ProductsApi(getApiConfiguration());
+      
+      const response = await productsApi.getAllProductsForStore(
+        filters?.search,
+        undefined, // productType
+        filters?.category,
+        filters?.maxPrice,
+        filters?.minPrice,
+        undefined, // brandFilter
+        filters?.inStock !== undefined ? (filters.inStock ? 'in-stock' : 'out-of-stock') : undefined,
+        undefined, // sort
+        true, // includeNoVariantProducts
+        true, // isActive
+        limit,
+        page
+      );
+
+      const products = response.data.data?.map(mapProduct) || [];
+      
+      return {
+        data: products,
+        pagination: {
+          page: response.data.currentPage || page,
+          limit: response.data.limit || limit,
+          total: response.data.totalItems || products.length,
+          totalPages: response.data.totalPages || 1,
+        },
+      };
+    } catch (error: any) {
+      console.error('Failed to get products:', error);
+      return {
+        data: [],
+        pagination: { page, limit, total: 0, totalPages: 0 },
+      };
+    }
+  },
+
+  /**
+   * Get a single product by ID
+   */
+  async getProduct(id: string): Promise<ApiResponse<Product>> {
+    try {
+      const productsApi = new ProductsApi(getApiConfiguration());
+      const response = await productsApi.getSingleProduct(id);
+      
+      return {
+        success: true,
+        data: mapProduct(response.data),
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        message: error.response?.data?.message || 'Failed to get product',
+        data: {} as Product,
+      };
+    }
+  },
+
+  /**
+   * Get featured/top selling products
+   */
+  async getFeaturedProducts(limit: number = 8): Promise<ApiResponse<Product[]>> {
+    try {
+      const productsApi = new ProductsApi(getApiConfiguration());
+      const response = await productsApi.getTopSellingProducts(limit, 1, true, true);
+      
+      const products = response.data.data?.map(mapProduct) || [];
+      
+      return {
+        success: true,
+        data: products,
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        message: error.response?.data?.message || 'Failed to get featured products',
+        data: [],
+      };
+    }
+  },
+
+  /**
+   * Get related products
+   */
+  async getRelatedProducts(productId: string, limit: number = 4): Promise<ApiResponse<Product[]>> {
+    try {
+      const productsApi = new ProductsApi(getApiConfiguration());
+      const response = await productsApi.getRelatedProducts(productId);
+      
+      const products = (response.data || [])
+        .map(mapProduct)
+        .slice(0, limit);
+      
+      return {
+        success: true,
+        data: products,
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        message: error.response?.data?.message || 'Failed to get related products',
+        data: [],
+      };
+    }
+  },
+
+  /**
+   * Get all categories
+   */
+  async getCategories(): Promise<ApiResponse<Category[]>> {
+    try {
+      const categoriesApi = new CategoriesApi(getApiConfiguration());
+      const response = await categoriesApi.getAllCategories();
+      
+      const categories: Category[] = (response.data.data || []).map((cat: any) => ({
+        id: cat.id || cat._id || '',
+        name: cat.name || '',
+        slug: cat.slug || cat.name?.toLowerCase().replace(/\s+/g, '-') || '',
+        description: cat.description,
+        image: cat.image,
+        productCount: cat.productCount || 0,
+      }));
+      
+      return {
+        success: true,
+        data: categories,
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        message: error.response?.data?.message || 'Failed to get categories',
+        data: [],
+      };
+    }
+  },
+
+  /**
+   * Search products
+   */
+  async searchProducts(query: string, limit: number = 10): Promise<ApiResponse<Product[]>> {
+    try {
+      const productsApi = new ProductsApi(getApiConfiguration());
+      const response = await productsApi.getAllProductsForStore(
+        query, // searchTerm
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        true,
+        true,
+        limit,
+        1
+      );
+      
+      const products = response.data.data?.map(mapProduct) || [];
+      
+      return {
+        success: true,
+        data: products,
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        message: error.response?.data?.message || 'Failed to search products',
+        data: [],
+      };
+    }
+  },
+};
+

package/src/lib/types/index.ts

@@ -0,0 +1,152 @@
+// Configuration Types
+export interface EcommerceConfig {
+  storeId: string;
+  storeName: string;
+  logo: string;
+  colors: {
+    primary: string;
+    secondary: string;
+    accent: string;
+  };
+  apiBaseUrl: string;
+  stripePublicKey: string;
+}
+
+// Product Types
+export interface Product {
+  id: string;
+  name: string;
+  description: string;
+  price: number;
+  compareAtPrice?: number;
+  images: string[];
+  category: string;
+  inStock: boolean;
+  stock?: number;
+  sku?: string;
+  tags?: string[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface ProductFilters {
+  category?: string;
+  minPrice?: number;
+  maxPrice?: number;
+  search?: string;
+  tags?: string[];
+  inStock?: boolean;
+}
+
+// Cart Types
+export interface CartItem {
+  productId: string;
+  quantity: number;
+  product: Product;
+}
+
+export interface Cart {
+  items: CartItem[];
+  total: number;
+  itemCount: number;
+}
+
+// Order Types
+export enum OrderStatus {
+  PENDING = 'pending',
+  PROCESSING = 'processing',
+  SHIPPED = 'shipped',
+  DELIVERED = 'delivered',
+  CANCELLED = 'cancelled',
+}
+
+export interface Order {
+  id: string;
+  orderNumber: string;
+  items: OrderItem[];
+  total: number;
+  status: OrderStatus;
+  shippingAddress: Address;
+  billingAddress: Address;
+  paymentStatus: 'pending' | 'paid' | 'failed';
+  stripeCheckoutUrl?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface OrderItem {
+  id: string;
+  productId: string;
+  productName: string;
+  productImage: string;
+  quantity: number;
+  price: number;
+}
+
+export interface Address {
+  fullName: string;
+  addressLine1: string;
+  addressLine2?: string;
+  city: string;
+  state: string;
+  zipCode: string;
+  country: string;
+  phone: string;
+}
+
+// Auth Types
+export interface User {
+  id: string;
+  email: string;
+  firstName: string;
+  lastName: string;
+  phone?: string;
+  avatar?: string;
+  createdAt: string;
+}
+
+export interface AuthTokens {
+  accessToken: string;
+  refreshToken: string;
+}
+
+export interface LoginCredentials {
+  email: string;
+  password: string;
+}
+
+export interface RegisterData {
+  email: string;
+  password: string;
+  firstName: string;
+  lastName: string;
+  phone?: string;
+}
+
+// API Response Types
+export interface ApiResponse<T> {
+  data: T;
+  message?: string;
+  success: boolean;
+}
+
+export interface PaginatedResponse<T> {
+  data: T[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+  };
+}
+
+// Category Types
+export interface Category {
+  id: string;
+  name: string;
+  slug: string;
+  description?: string;
+  image?: string;
+  productCount: number;
+}
+

package/src/lib/utils/colors.ts

@@ -0,0 +1,51 @@
+/**
+ * Convert hex color to RGB array
+ */
+export function hexToRgb(hex: string): [number, number, number] {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result
+    ? [
+        parseInt(result[1], 16),
+        parseInt(result[2], 16),
+        parseInt(result[3], 16),
+      ]
+    : [0, 0, 0];
+}
+
+/**
+ * Generate color shades from a base color
+ */
+export function generateColorShades(baseColor: string) {
+  const [r, g, b] = hexToRgb(baseColor);
+  
+  const shades = {
+    50: lighten(r, g, b, 0.95),
+    100: lighten(r, g, b, 0.9),
+    200: lighten(r, g, b, 0.75),
+    300: lighten(r, g, b, 0.6),
+    400: lighten(r, g, b, 0.3),
+    500: `${r}, ${g}, ${b}`,
+    600: darken(r, g, b, 0.1),
+    700: darken(r, g, b, 0.2),
+    800: darken(r, g, b, 0.3),
+    900: darken(r, g, b, 0.4),
+    950: darken(r, g, b, 0.5),
+  };
+  
+  return shades;
+}
+
+function lighten(r: number, g: number, b: number, amount: number): string {
+  const newR = Math.round(r + (255 - r) * amount);
+  const newG = Math.round(g + (255 - g) * amount);
+  const newB = Math.round(b + (255 - b) * amount);
+  return `${newR}, ${newG}, ${newB}`;
+}
+
+function darken(r: number, g: number, b: number, amount: number): string {
+  const newR = Math.round(r * (1 - amount));
+  const newG = Math.round(g * (1 - amount));
+  const newB = Math.round(b * (1 - amount));
+  return `${newR}, ${newG}, ${newB}`;
+}
+

package/src/lib/utils/format.ts

@@ -0,0 +1,48 @@
+/**
+ * Format price with currency symbol
+ */
+export function formatPrice(price: number, currency: string = 'USD'): string {
+  return new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency,
+  }).format(price);
+}
+
+/**
+ * Format date
+ */
+export function formatDate(date: string | Date, format: 'short' | 'long' = 'short'): string {
+  const d = typeof date === 'string' ? new Date(date) : date;
+  
+  if (format === 'long') {
+    return new Intl.DateTimeFormat('en-US', {
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit',
+    }).format(d);
+  }
+  
+  return new Intl.DateTimeFormat('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+  }).format(d);
+}
+
+/**
+ * Truncate text with ellipsis
+ */
+export function truncate(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength) + '...';
+}
+
+/**
+ * Generate initials from name
+ */
+export function getInitials(firstName: string, lastName: string): string {
+  return `${firstName.charAt(0)}${lastName.charAt(0)}`.toUpperCase();
+}
+

package/src/providers/AuthProvider.tsx

@@ -0,0 +1,117 @@
+'use client';
+
+import React, { createContext, useContext, useState, useEffect, useCallback } from 'react';
+import { User, LoginCredentials, RegisterData } from '@/lib/types';
+import { authApi } from '@/lib/api/auth';
+import { getAuthToken } from '@/lib/api/client';
+
+interface AuthContextValue {
+  user: User | null;
+  isAuthenticated: boolean;
+  isLoading: boolean;
+  login: (credentials: LoginCredentials) => Promise<void>;
+  register: (data: RegisterData) => Promise<void>;
+  logout: () => Promise<void>;
+  updateUser: (data: Partial<User>) => Promise<void>;
+  refreshUser: () => Promise<void>;
+}
+
+const AuthContext = createContext<AuthContextValue | undefined>(undefined);
+
+export function useAuth() {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error('useAuth must be used within AuthProvider');
+  }
+  return context;
+}
+
+interface AuthProviderProps {
+  children: React.ReactNode;
+}
+
+export function AuthProvider({ children }: AuthProviderProps) {
+  const [user, setUser] = useState<User | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+
+  const refreshUser = useCallback(async () => {
+    try {
+      const token = getAuthToken();
+      if (token) {
+        const response = await authApi.getCurrentUser();
+        if (response.success) {
+          setUser(response.data);
+        }
+      }
+    } catch (error) {
+      console.error('Failed to refresh user:', error);
+      setUser(null);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    refreshUser();
+  }, [refreshUser]);
+
+  const login = async (credentials: LoginCredentials) => {
+    setIsLoading(true);
+    try {
+      const response = await authApi.login(credentials);
+      if (response.success) {
+        setUser(response.data.user);
+      }
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const register = async (data: RegisterData) => {
+    setIsLoading(true);
+    try {
+      const response = await authApi.register(data);
+      if (response.success) {
+        setUser(response.data.user);
+      }
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const logout = async () => {
+    setIsLoading(true);
+    try {
+      await authApi.logout();
+      setUser(null);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const updateUser = async (data: Partial<User>) => {
+    try {
+      const response = await authApi.updateProfile(data);
+      if (response.success) {
+        setUser(response.data);
+      }
+    } catch (error) {
+      console.error('Failed to update user:', error);
+      throw error;
+    }
+  };
+
+  const value: AuthContextValue = {
+    user,
+    isAuthenticated: !!user,
+    isLoading,
+    login,
+    register,
+    logout,
+    updateUser,
+    refreshUser,
+  };
+
+  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
+}
+

package/src/providers/CartProvider.tsx

@@ -0,0 +1,131 @@
+'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';
+
+interface CartContextValue {
+  cart: Cart | null;
+  isLoading: boolean;
+  addToCart: (productId: string, quantity?: number) => Promise<void>;
+  updateQuantity: (productId: string, quantity: number) => Promise<void>;
+  removeFromCart: (productId: string) => Promise<void>;
+  clearCart: () => Promise<void>;
+  refreshCart: () => Promise<void>;
+}
+
+const CartContext = createContext<CartContextValue | undefined>(undefined);
+
+export function useCart() {
+  const context = useContext(CartContext);
+  if (!context) {
+    throw new Error('useCart must be used within CartProvider');
+  }
+  return context;
+}
+
+interface CartProviderProps {
+  children: React.ReactNode;
+}
+
+export function CartProvider({ children }: CartProviderProps) {
+  const [cart, setCart] = useState<Cart | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const { isAuthenticated } = useAuth();
+
+  const refreshCart = useCallback(async () => {
+    if (!isAuthenticated) {
+      setCart(null);
+      return;
+    }
+
+    try {
+      const response = await cartApi.getCart();
+      if (response.success) {
+        setCart(response.data);
+      }
+    } catch (error) {
+      console.error('Failed to fetch cart:', error);
+    }
+  }, [isAuthenticated]);
+
+  useEffect(() => {
+    refreshCart();
+  }, [refreshCart]);
+
+  const addToCart = async (productId: string, quantity: number = 1) => {
+    setIsLoading(true);
+    try {
+      const response = await cartApi.addToCart(productId, quantity);
+      if (response.success) {
+        setCart(response.data);
+        toast.success('Added to cart!');
+      }
+    } catch (error: any) {
+      toast.error(error.response?.data?.message || 'Failed to add to cart');
+      throw error;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const updateQuantity = async (productId: string, quantity: number) => {
+    setIsLoading(true);
+    try {
+      const response = await cartApi.updateCartItem(productId, quantity);
+      if (response.success) {
+        setCart(response.data);
+      }
+    } catch (error: any) {
+      toast.error(error.response?.data?.message || 'Failed to update cart');
+      throw error;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  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');
+      }
+    } catch (error: any) {
+      toast.error(error.response?.data?.message || 'Failed to remove from cart');
+      throw error;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const clearCart = async () => {
+    setIsLoading(true);
+    try {
+      await cartApi.clearCart();
+      setCart({ items: [], total: 0, itemCount: 0 });
+      toast.success('Cart cleared');
+    } catch (error: any) {
+      toast.error(error.response?.data?.message || 'Failed to clear cart');
+      throw error;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const value: CartContextValue = {
+    cart,
+    isLoading,
+    addToCart,
+    updateQuantity,
+    removeFromCart,
+    clearCart,
+    refreshCart,
+  };
+
+  return <CartContext.Provider value={value}>{children}</CartContext.Provider>;
+}
+