hey-pharmacist-ecommerce 1.0.0

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

@@ -0,0 +1,193 @@
+/**
+ * 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/config.ts

@@ -0,0 +1,76 @@
+/**
+ * API Adapter Configuration
+ * Bridges the frontend components with the real backend APIs
+ */
+
+import { Configuration } from '../Apis/configuration';
+import { EcommerceConfig } from '../types';
+
+let apiConfiguration: Configuration | null = null;
+let currentConfig: EcommerceConfig | null = null;
+
+/**
+ * Initialize the API configuration with store settings
+ */
+export function initializeApiAdapter(config: EcommerceConfig): Configuration {
+  currentConfig = config;
+  
+  apiConfiguration = new Configuration({
+    basePath: config.apiBaseUrl,
+    apiKey: () => config.storeId, // x-store-key header
+    accessToken: () => getAuthToken() || '', // Bearer token
+  });
+
+  return apiConfiguration;
+}
+
+/**
+ * Get the current API configuration
+ */
+export function getApiConfiguration(): Configuration {
+  if (!apiConfiguration) {
+    throw new Error('API adapter not initialized. Call initializeApiAdapter first.');
+  }
+  return apiConfiguration;
+}
+
+/**
+ * Get the current ecommerce config
+ */
+export function getCurrentConfig(): EcommerceConfig {
+  if (!currentConfig) {
+    throw new Error('API adapter not initialized.');
+  }
+  return currentConfig;
+}
+
+// Token management
+const TOKEN_KEY = 'ecommerce_access_token';
+
+export function setAuthToken(token: string): void {
+  if (typeof window !== 'undefined') {
+    localStorage.setItem(TOKEN_KEY, token);
+    // Update the configuration with new token
+    if (apiConfiguration) {
+      apiConfiguration.accessToken = () => token;
+    }
+  }
+}
+
+export function getAuthToken(): string | null {
+  if (typeof window !== 'undefined') {
+    return localStorage.getItem(TOKEN_KEY);
+  }
+  return null;
+}
+
+export function clearAuthToken(): void {
+  if (typeof window !== 'undefined') {
+    localStorage.removeItem(TOKEN_KEY);
+    // Clear from configuration
+    if (apiConfiguration) {
+      apiConfiguration.accessToken = () => '';
+    }
+  }
+}
+

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

@@ -0,0 +1,13 @@
+/**
+ * API Adapter - Main Export
+ * Central export point for all adapters
+ */
+
+export { initializeApiAdapter, getApiConfiguration, getCurrentConfig, setAuthToken, getAuthToken, clearAuthToken } from './config';
+export { authAdapter } from './auth-adapter';
+export { productsAdapter } from './products-adapter';
+export { cartAdapter } from './cart-adapter';
+export { ordersAdapter } from './orders-adapter';
+export type { CreateOrderData } from './orders-adapter';
+export * from './mappers';
+

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

@@ -0,0 +1,147 @@
+/**
+ * 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(),
+  };
+}
+

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

@@ -0,0 +1,195 @@
+/**
+ * Orders API Adapter
+ * Connects frontend orders to real backend orders APIs
+ */
+
+import { OrdersApi } from '../Apis/apis/orders-api';
+import { ManualOrderDTO } from '../Apis/models';
+import { getApiConfiguration } from './config';
+import { mapOrder } from './mappers';
+import { Order, ApiResponse, PaginatedResponse, Address } from '../types';
+
+export interface CreateOrderData {
+  shippingAddress: Address;
+  billingAddress: Address;
+  sameAsShipping?: boolean;
+  paymentMethod?: string;
+}
+
+export const ordersAdapter = {
+  /**
+   * Get user's orders with pagination
+   */
+  async getOrders(page: number = 1, limit: number = 10): Promise<PaginatedResponse<Order>> {
+    try {
+      const ordersApi = new OrdersApi(getApiConfiguration());
+      const response = await ordersApi.getAllOrders(
+        undefined, // paymentStatus
+        undefined, // orderStatus
+        page,
+        limit,
+        undefined, // search
+        undefined, // createdAfter
+        undefined, // createdBefore
+        undefined  // userId
+      );
+      
+      const orders = response.data.data?.map(mapOrder) || [];
+      
+      return {
+        data: orders,
+        pagination: {
+          page: response.data.page || page,
+          limit: response.data.limit || limit,
+          total: response.data.total || orders.length,
+          totalPages: response.data.totalPages || 1,
+        },
+      };
+    } catch (error: any) {
+      console.error('Failed to get orders:', error);
+      return {
+        data: [],
+        pagination: { page, limit, total: 0, totalPages: 0 },
+      };
+    }
+  },
+
+  /**
+   * Get current/active orders
+   * Orders that are not delivered or cancelled
+   */
+  async getCurrentOrders(): Promise<ApiResponse<Order[]>> {
+    try {
+      const ordersApi = new OrdersApi(getApiConfiguration());
+      const response = await ordersApi.getUserOrders();
+      
+      const orders = (response.data || [])
+        .map((order: any) => mapOrder(order))
+        .filter((order: Order) => 
+          order.status !== 'delivered' && 
+          order.status !== 'cancelled'
+        );
+      
+      return {
+        success: true,
+        data: orders,
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        message: error.response?.data?.message || 'Failed to get current orders',
+        data: [],
+      };
+    }
+  },
+
+  /**
+   * Get a single order by ID
+   */
+  async getOrder(id: string): Promise<ApiResponse<Order>> {
+    try {
+      const ordersApi = new OrdersApi(getApiConfiguration());
+      const response = await ordersApi.getSingleOrder(id);
+      
+      return {
+        success: true,
+        data: mapOrder(response.data),
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        message: error.response?.data?.message || 'Failed to get order',
+        data: {} as Order,
+      };
+    }
+  },
+
+  /**
+   * Create a new order
+   */
+  async createOrder(data: CreateOrderData): Promise<ApiResponse<Order>> {
+    try {
+      const ordersApi = new OrdersApi(getApiConfiguration());
+      
+      // Build the order DTO
+      // Note: Cart items are handled automatically by backend
+      const orderDTO: ManualOrderDTO = {
+        items: [], // Will be populated from user's cart by backend
+        paymentMethod: 'Card' as any, // Card for Stripe, Cash for COD
+        orderStatus: 'Pending' as any,
+        manualDiscount: {} as any,
+        discountId: '',
+        manualShipping: {} as any,
+        paymentDueDate: new Date(),
+        chargeTax: true,
+        orderRemindingDates: [],
+      };
+      
+      const response = await ordersApi.createCheckout(
+        orderDTO,
+        true, // isDelivery
+        undefined, // userId (from token)
+        undefined, // rateId
+        undefined // billingAddressId
+      );
+      
+      return {
+        success: true,
+        data: mapOrder(response.data),
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        message: error.response?.data?.message || 'Failed to create order',
+        data: {} as Order,
+      };
+    }
+  },
+
+  /**
+   * Cancel an order
+   */
+  async cancelOrder(id: string): Promise<ApiResponse<Order>> {
+    try {
+      const ordersApi = new OrdersApi(getApiConfiguration());
+      const response = await ordersApi.cancelOrder(id);
+      
+      return {
+        success: true,
+        data: mapOrder(response.data),
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        message: error.response?.data?.message || 'Failed to cancel order',
+        data: {} as Order,
+      };
+    }
+  },
+
+  /**
+   * Get order tracking information
+   */
+  async getOrderTracking(id: string): Promise<ApiResponse<any>> {
+    try {
+      const ordersApi = new OrdersApi(getApiConfiguration());
+      const response = await ordersApi.getSingleOrder(id);
+      
+      return {
+        success: true,
+        data: {
+          orderStatus: response.data.orderStatus,
+          orderTimeLine: response.data.orderTimeLine,
+          shippingInfo: response.data.shippingInfo,
+        },
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        message: error.response?.data?.message || 'Failed to get tracking',
+        data: {},
+      };
+    }
+  },
+};
+