hey-pharmacist-ecommerce 1.0.4 → 1.0.6

package/src/lib/api/orders.ts

@@ -1,53 +0,0 @@
-import { ordersAdapter, CreateOrderData as AdapterCreateOrderData } from '@/lib/api-adapter';
-import { Order, ApiResponse, PaginatedResponse, Address } from '@/lib/types';
-
-export interface CreateOrderData {
-  shippingAddress: Address;
-  billingAddress: Address;
-  sameAsShipping?: boolean;
-}
-
-export const ordersApi = {
-  /**
-   * Get user's orders with pagination
-   */
-  async getOrders(page: number = 1, limit: number = 10): Promise<PaginatedResponse<Order>> {
-    return await ordersAdapter.getOrders(page, limit);
-  },
-
-  /**
-   * Get current/active orders
-   */
-  async getCurrentOrders(): Promise<ApiResponse<Order[]>> {
-    return await ordersAdapter.getCurrentOrders();
-  },
-
-  /**
-   * Get a single order by ID
-   */
-  async getOrder(id: string): Promise<ApiResponse<Order>> {
-    return await ordersAdapter.getOrder(id);
-  },
-
-  /**
-   * Create a new order
-   */
-  async createOrder(data: CreateOrderData): Promise<ApiResponse<Order>> {
-    return await ordersAdapter.createOrder(data);
-  },
-
-  /**
-   * Cancel an order
-   */
-  async cancelOrder(id: string): Promise<ApiResponse<Order>> {
-    return await ordersAdapter.cancelOrder(id);
-  },
-
-  /**
-   * Get order tracking information
-   */
-  async getOrderTracking(id: string): Promise<ApiResponse<any>> {
-    return await ordersAdapter.getOrderTracking(id);
-  },
-};
-

package/src/lib/api/products.ts

@@ -1,51 +0,0 @@
-import { productsAdapter } from '@/lib/api-adapter';
-import { Product, ApiResponse, PaginatedResponse, ProductFilters, Category } from '@/lib/types';
-
-export const productsApi = {
-  /**
-   * Get all products with optional filters and pagination
-   */
-  async getProducts(
-    filters?: ProductFilters,
-    page: number = 1,
-    limit: number = 20
-  ): Promise<PaginatedResponse<Product>> {
-    return await productsAdapter.getProducts(filters, page, limit);
-  },
-
-  /**
-   * Get a single product by ID
-   */
-  async getProduct(id: string): Promise<ApiResponse<Product>> {
-    return await productsAdapter.getProduct(id);
-  },
-
-  /**
-   * Get featured products
-   */
-  async getFeaturedProducts(limit: number = 8): Promise<ApiResponse<Product[]>> {
-    return await productsAdapter.getFeaturedProducts(limit);
-  },
-
-  /**
-   * Get related products
-   */
-  async getRelatedProducts(productId: string, limit: number = 4): Promise<ApiResponse<Product[]>> {
-    return await productsAdapter.getRelatedProducts(productId, limit);
-  },
-
-  /**
-   * Get all categories
-   */
-  async getCategories(): Promise<ApiResponse<Category[]>> {
-    return await productsAdapter.getCategories();
-  },
-
-  /**
-   * Search products
-   */
-  async searchProducts(query: string, limit: number = 10): Promise<ApiResponse<Product[]>> {
-    return await productsAdapter.searchProducts(query, limit);
-  },
-};
-

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

@@ -1,196 +0,0 @@
-/**
- * Auth API Adapter
- * Connects frontend auth to real backend auth APIs
- */
-
-import { AuthApi } from '../Apis/apis/auth-api';
-import { UsersApi } from '../Apis/apis/users-api';
-import { LoginDto, CreateUserDto } from '../Apis/models';
-import { getApiConfiguration, setAuthToken, clearAuthToken } from './config';
-import { mapSessionData, mapUser } from './mappers';
-import { User, LoginCredentials, RegisterData, ApiResponse } from '../types';
-
-export const authAdapter = {
-  /**
-   * Register a new user
-   */
-  async register(data: RegisterData): Promise<ApiResponse<{ user: User; token: string }>> {
-    try {
-      const authApi = new AuthApi(getApiConfiguration());
-      
-      // Note: CreateUserDto doesn't include password
-      // Password is sent via LoginDto in signup endpoint
-      const loginDto: LoginDto = {
-        email: data.email,
-        password: data.password,
-      };
-
-      // Try signing up - backend signup uses email/password in LoginDto format
-      const response = await authApi.signup(loginDto as any);
-      const { user, token } = mapSessionData(response.data);
-      
-      setAuthToken(token);
-      
-      return {
-        success: true,
-        data: { user, token },
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        message: error.response?.data?.message || 'Registration failed',
-        data: { user: {} as User, token: '' },
-      };
-    }
-  },
-
-  /**
-   * Login user
-   */
-  async login(credentials: LoginCredentials): Promise<ApiResponse<{ user: User; token: string }>> {
-    try {
-      const authApi = new AuthApi(getApiConfiguration());
-      
-      const loginDto: LoginDto = {
-        email: credentials.email,
-        password: credentials.password,
-      };
-
-      const response = await authApi.signin(loginDto);
-      const { user, token } = mapSessionData(response.data);
-      
-      setAuthToken(token);
-      
-      return {
-        success: true,
-        data: { user, token },
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        message: error.response?.data?.message || 'Login failed',
-        data: { user: {} as User, token: '' },
-      };
-    }
-  },
-
-  /**
-   * Logout user
-   */
-  async logout(): Promise<void> {
-    clearAuthToken();
-  },
-
-  /**
-   * Get current user
-   */
-  async getCurrentUser(): Promise<ApiResponse<User>> {
-    try {
-      const usersApi = new UsersApi(getApiConfiguration());
-      const response = await usersApi.getMyProfile();
-      
-      return {
-        success: true,
-        data: mapUser(response.data),
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        message: error.response?.data?.message || 'Failed to get user',
-        data: {} as User,
-      };
-    }
-  },
-
-  /**
-   * Update user profile
-   */
-  async updateProfile(data: Partial<User>): Promise<ApiResponse<User>> {
-    try {
-      const usersApi = new UsersApi(getApiConfiguration());
-      
-      const updateData: any = {};
-      if (data.firstName) updateData.firstname = data.firstName;
-      if (data.lastName) updateData.lastname = data.lastName;
-      if (data.phone) updateData.phoneNumber = data.phone;
-      if (data.email) updateData.email = data.email;
-      
-      const response = await usersApi.updateMyProfile(updateData);
-      
-      return {
-        success: true,
-        data: mapUser(response.data),
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        message: error.response?.data?.message || 'Failed to update profile',
-        data: {} as User,
-      };
-    }
-  },
-
-  /**
-   * Change password
-   */
-  async changePassword(currentPassword: string, newPassword: string): Promise<ApiResponse<void>> {
-    try {
-      const authApi = new AuthApi(getApiConfiguration());
-      await authApi.changePassword(currentPassword, newPassword);
-      
-      return {
-        success: true,
-        data: undefined,
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        message: error.response?.data?.message || 'Failed to change password',
-        data: undefined,
-      };
-    }
-  },
-
-  /**
-   * Request password reset
-   */
-  async forgotPassword(email: string): Promise<ApiResponse<void>> {
-    try {
-      const authApi = new AuthApi(getApiConfiguration());
-      await authApi.sendForgetPasswordEmail({ email });
-      
-      return {
-        success: true,
-        data: undefined,
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        message: error.response?.data?.message || 'Failed to send reset email',
-        data: undefined,
-      };
-    }
-  },
-
-  /**
-   * Reset password with token
-   */
-  async resetPassword(token: string, newPassword: string): Promise<ApiResponse<void>> {
-    try {
-      const authApi = new AuthApi(getApiConfiguration());
-      await authApi.resetPassword(newPassword, token);
-      
-      return {
-        success: true,
-        data: undefined,
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        message: error.response?.data?.message || 'Failed to reset password',
-        data: undefined,
-      };
-    }
-  },
-};
-

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

@@ -1,193 +0,0 @@
-/**
- * Cart API Adapter
- * Connects frontend cart to real backend cart APIs
- */
-
-import { CartApi } from '../Apis/apis/cart-api';
-import { CartBodyDTO } from '../Apis/models';
-import { getApiConfiguration } from './config';
-import { mapCart } from './mappers';
-import { Cart, ApiResponse } from '../types';
-
-export const cartAdapter = {
-  /**
-   * Get user's cart
-   */
-  async getCart(): Promise<ApiResponse<Cart>> {
-    try {
-      const cartApi = new CartApi(getApiConfiguration());
-      const response = await cartApi.getUserCart();
-      
-      return {
-        success: true,
-        data: mapCart(response.data),
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        message: error.response?.data?.message || 'Failed to get cart',
-        data: { items: [], total: 0, itemCount: 0 },
-      };
-    }
-  },
-
-  /**
-   * Add item to cart
-   * In your backend, cart is updated as a whole, not individual items
-   */
-  async addToCart(productId: string, variantId: string, quantity: number = 1): Promise<ApiResponse<Cart>> {
-    try {
-      const cartApi = new CartApi(getApiConfiguration());
-      
-      // First get current cart
-      const currentCartResponse = await cartApi.getUserCart();
-      const currentCart = currentCartResponse.data;
-      
-      // Build updated cart body
-      const existingItems = currentCart.cartBody?.items || [];
-      const existingIndex = existingItems.findIndex(
-        (p: any) => p.productVariantId === variantId
-      );
-      
-      let updatedItems;
-      if (existingIndex >= 0) {
-        // Update existing item
-        updatedItems = [...existingItems];
-        updatedItems[existingIndex] = {
-          ...updatedItems[existingIndex],
-          quantity: updatedItems[existingIndex].quantity + quantity,
-        };
-      } else {
-        // Add new item
-        updatedItems = [
-          ...existingItems,
-          {
-            productVariantId: variantId,
-            quantity,
-          },
-        ];
-      }
-      
-      const cartBodyDTO: CartBodyDTO = {
-        items: updatedItems,
-      };
-      
-      await cartApi.handleUserCart(cartBodyDTO);
-      
-      // Get updated cart
-      const updatedCartResponse = await cartApi.getUserCart();
-      
-      return {
-        success: true,
-        data: mapCart(updatedCartResponse.data),
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        message: error.response?.data?.message || 'Failed to add to cart',
-        data: { items: [], total: 0, itemCount: 0 },
-      };
-    }
-  },
-
-  /**
-   * Update cart item quantity
-   */
-  async updateCartItem(productId: string, variantId: string, quantity: number): Promise<ApiResponse<Cart>> {
-    try {
-      const cartApi = new CartApi(getApiConfiguration());
-      
-      // Get current cart
-      const currentCartResponse = await cartApi.getUserCart();
-      const currentCart = currentCartResponse.data;
-      
-      // Update the specific item
-      const updatedItems = (currentCart.cartBody?.items || []).map((p: any) => {
-        if (p.productVariantId === variantId) {
-          return { ...p, quantity };
-        }
-        return p;
-      });
-      
-      const cartBodyDTO: CartBodyDTO = {
-        items: updatedItems,
-      };
-      
-      await cartApi.handleUserCart(cartBodyDTO);
-      
-      // Get updated cart
-      const updatedCartResponse = await cartApi.getUserCart();
-      
-      return {
-        success: true,
-        data: mapCart(updatedCartResponse.data),
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        message: error.response?.data?.message || 'Failed to update cart',
-        data: { items: [], total: 0, itemCount: 0 },
-      };
-    }
-  },
-
-  /**
-   * Remove item from cart
-   */
-  async removeFromCart(productId: string, variantId: string): Promise<ApiResponse<Cart>> {
-    try {
-      const cartApi = new CartApi(getApiConfiguration());
-      
-      // Get current cart
-      const currentCartResponse = await cartApi.getUserCart();
-      const currentCart = currentCartResponse.data;
-      
-      // Filter out the item
-      const updatedItems = (currentCart.cartBody?.items || []).filter(
-        (p: any) => p.productVariantId !== variantId
-      );
-      
-      const cartBodyDTO: CartBodyDTO = {
-        items: updatedItems,
-      };
-      
-      await cartApi.handleUserCart(cartBodyDTO);
-      
-      // Get updated cart
-      const updatedCartResponse = await cartApi.getUserCart();
-      
-      return {
-        success: true,
-        data: mapCart(updatedCartResponse.data),
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        message: error.response?.data?.message || 'Failed to remove from cart',
-        data: { items: [], total: 0, itemCount: 0 },
-      };
-    }
-  },
-
-  /**
-   * Clear cart
-   */
-  async clearCart(): Promise<ApiResponse<void>> {
-    try {
-      const cartApi = new CartApi(getApiConfiguration());
-      await cartApi.clearCart();
-      
-      return {
-        success: true,
-        data: undefined,
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        message: error.response?.data?.message || 'Failed to clear cart',
-        data: undefined,
-      };
-    }
-  },
-};
-

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

@@ -1,147 +0,0 @@
-/**
- * Data Mappers
- * Convert backend models to frontend types
- */
-
-import { UserEntity, TUserSessionData } from '../Apis/models';
-import { ExtendedProductDTO } from '../Apis/models';
-import { CartResponseDto } from '../Apis/models';
-import { PopulatedOrder } from '../Apis/models';
-import { User, Product, Cart, Order, OrderStatus, CartItem } from '../types';
-
-/**
- * Map backend UserEntity to frontend User
- */
-export function mapUser(backendUser: UserEntity): User {
-  return {
-    id: backendUser.id || backendUser._id || '',
-    email: backendUser.email || '',
-    firstName: backendUser.firstname || '',
-    lastName: backendUser.lastname || '',
-    phone: backendUser.phoneNumber,
-    avatar: backendUser.avatar,
-    createdAt: backendUser.createdAt ? backendUser.createdAt.toString() : new Date().toISOString(),
-  };
-}
-
-/**
- * Map backend session data to user and token
- */
-export function mapSessionData(sessionData: TUserSessionData): { user: User; token: string } {
-  return {
-    user: mapUser(sessionData.userData),
-    token: sessionData.authToken,
-  };
-}
-
-/**
- * Map backend product to frontend Product
- */
-export function mapProduct(backendProduct: ExtendedProductDTO): Product {
-  const images = backendProduct.productMedia?.map((media) => media.file) || [];
-  
-  return {
-    id: backendProduct.id || backendProduct._id || '',
-    name: backendProduct.name || '',
-    description: backendProduct.description || '',
-    price: backendProduct.finalPrice || 0,
-    compareAtPrice: backendProduct.isDiscounted ? backendProduct.priceBeforeDiscount : undefined,
-    images: images.filter(Boolean),
-    category: backendProduct.parentCategories?.[0] || '',
-    inStock: (backendProduct.inventoryCount || 0) > 0,
-    stock: backendProduct.inventoryCount,
-    sku: backendProduct.sku,
-    tags: backendProduct.tags || [],
-    createdAt: backendProduct.createdAt ? backendProduct.createdAt.toString() : new Date().toISOString(),
-    updatedAt: backendProduct.updatedAt ? backendProduct.updatedAt.toString() : new Date().toISOString(),
-  };
-}
-
-/**
- * Map backend cart to frontend Cart
- */
-export function mapCart(backendCart: CartResponseDto): Cart {
-  const items: CartItem[] = [];
-  
-  // Map cart body items
-  if (backendCart.cartBody?.items) {
-    backendCart.cartBody.items.forEach((item: any) => {
-      if (item.productVariantData) {
-        // Extract product info from variant data
-        const productData = item.productVariantData.product || item.productVariantData;
-        items.push({
-          productId: productData.id || productData._id || '',
-          quantity: item.quantity || 0,
-          product: mapProduct(productData),
-        });
-      }
-    });
-  }
-
-  return {
-    items,
-    total: backendCart.total || 0,
-    itemCount: items.reduce((sum, item) => sum + item.quantity, 0),
-  };
-}
-
-/**
- * Map backend order status to frontend OrderStatus
- */
-export function mapOrderStatus(backendStatus: string): OrderStatus {
-  const statusMap: Record<string, OrderStatus> = {
-    'pending': OrderStatus.PENDING,
-    'processing': OrderStatus.PROCESSING,
-    'shipped': OrderStatus.SHIPPED,
-    'delivered': OrderStatus.DELIVERED,
-    'cancelled': OrderStatus.CANCELLED,
-  };
-  
-  return statusMap[backendStatus.toLowerCase()] || OrderStatus.PENDING;
-}
-
-/**
- * Map backend order to frontend Order
- */
-export function mapOrder(backendOrder: PopulatedOrder): Order {
-  return {
-    id: backendOrder.id || backendOrder._id || '',
-    orderNumber: backendOrder.stringId || backendOrder.id || backendOrder._id || '',
-    items: backendOrder.items?.map((item: any) => ({
-      id: item.id || item._id || '',
-      productId: item.productVariantData?.product?.id || item.productVariantData?.id || '',
-      productName: item.productVariantData?.product?.name || item.productVariantData?.name || '',
-      productImage: item.productVariantData?.product?.productMedia?.[0]?.url || 
-                    item.productVariantData?.productMedia?.[0]?.url || '',
-      quantity: item.quantity || 0,
-      price: item.productVariantData?.finalPrice || 0,
-    })) || [],
-    total: backendOrder.grandTotal || 0,
-    status: mapOrderStatus(backendOrder.orderStatus || 'pending'),
-    shippingAddress: backendOrder.shippingInfo?.addressTo ? {
-      fullName: backendOrder.shippingInfo.addressTo.name || '',
-      addressLine1: backendOrder.shippingInfo.addressTo.street1 || '',
-      addressLine2: backendOrder.shippingInfo.addressTo.street2 || '',
-      city: backendOrder.shippingInfo.addressTo.city || '',
-      state: backendOrder.shippingInfo.addressTo.state || '',
-      zipCode: backendOrder.shippingInfo.addressTo.zip || '',
-      country: backendOrder.shippingInfo.addressTo.country || '',
-      phone: backendOrder.shippingInfo.addressTo.phone || '',
-    } : {} as any,
-    billingAddress: backendOrder.shippingInfo?.addressTo ? {
-      fullName: backendOrder.shippingInfo.addressTo.name || '',
-      addressLine1: backendOrder.shippingInfo.addressTo.street1 || '',
-      addressLine2: backendOrder.shippingInfo.addressTo.street2 || '',
-      city: backendOrder.shippingInfo.addressTo.city || '',
-      state: backendOrder.shippingInfo.addressTo.state || '',
-      zipCode: backendOrder.shippingInfo.addressTo.zip || '',
-      country: backendOrder.shippingInfo.addressTo.country || '',
-      phone: backendOrder.shippingInfo.addressTo.phone || '',
-    } : {} as any,
-    paymentStatus: (backendOrder.payment?.paymentStatus?.toLowerCase() || 'unpaid') as any,
-    stripeCheckoutUrl: backendOrder.payment?.hostedInvoiceUrl,
-    createdAt: backendOrder.createdAt ? backendOrder.createdAt.toString() : new Date().toISOString(),
-    updatedAt: backendOrder.updatedAt ? backendOrder.updatedAt.toString() : new Date().toISOString(),
-  };
-}
-