@meeovi/layer-commerce 1.0.10 → 1.0.13

package/app/composables/stores/cartStore.ts

@@ -0,0 +1,300 @@
+// stores/cartStore.ts
+import { defineStore } from 'pinia'
+import { MagentoService } from '~/services/magento'
+
+interface MagentoProduct {
+  sku: string
+  name: string
+  price: number
+  qty: number
+  quote_id?: string
+  item_id?: string
+}
+
+interface CartState {
+  isGuest: boolean
+  items: MagentoProduct[]
+  total: number
+  quoteId: string | null
+  magentoService: MagentoService
+}
+
+
+export const useCartStore = defineStore('cart', {
+  state: () => ({
+    isGuest: true,
+    items: [] as MagentoProduct[],
+    total: 0,
+    quoteId: null as string | null,
+    magentoService: new MagentoService()
+  }),
+
+  actions: {
+    async initializeCart() {
+      const auth = useAuth()
+      this.isGuest = !auth.token.value
+
+      try {
+        if (this.isGuest) {
+          await this.createGuestCart()
+        } else {
+          await this.createCustomerCart()
+        }
+      } catch (error) {
+        errorHandler.handle(error)
+      }
+    },
+
+    async createGuestCart() {
+      const response = await fetch(`${process.env.MAGENTO_API_URL}/guest-carts`, {
+        method: 'POST'
+      })
+      const quoteId = await response.json()
+      this.quoteId = quoteId as string
+    },
+
+    async createCustomerCart() {
+      const auth = useAuth()
+      const response = await fetch(`${process.env.MAGENTO_API_URL}/carts/mine`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${auth.token.value}`
+        }
+      })
+      this.quoteId = await response.json()
+    },
+
+    async addItem(product: MagentoProduct) {
+      const loading = useLoading()
+      loading.startLoading('Adding to cart...')
+
+      try {
+        // Check authentication
+        const auth = useAuth()
+        if (auth.isTokenExpired()) {
+          await auth.refreshAccessToken()
+        }
+
+        // Check inventory
+        const inventory = useInventory()
+        await inventory.checkInventory(product.sku, product.qty)
+
+        // If no quote ID, create cart
+        if (!this.quoteId) {
+          await this.initializeCart()
+        }
+
+        // Ensure quoteId exists before proceeding
+        if (!this.quoteId) {
+          throw new CartError('Failed to create cart', 'CART_ERROR')
+        }
+
+        // Add to Magento cart
+        const response = await fetch(`${process.env.MAGENTO_API_URL}/carts/mine/items`, {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${auth.token.value}`,
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({
+            cartItem: {
+              sku: product.sku,
+              qty: product.qty,
+              quote_id: this.quoteId
+            }
+          })
+        })
+
+        if (!response.ok) {
+          throw new CartError('Failed to add item to cart', 'CART_ERROR')
+        }
+
+        const cartItem = await response.json()
+
+        // Update local cart state
+        const existingItem = this.items.find(item => item.sku === product.sku)
+        if (existingItem) {
+          existingItem.qty += product.qty
+        } else {
+          this.items.push({
+            ...product,
+            item_id: cartItem.item_id
+          })
+        }
+
+        // Calculate taxes
+        const tax = useTax()
+        if (this.quoteId) {
+          await tax.calculateTax(this.quoteId)
+        }
+
+        // Cache product data
+        const cache = useCache()
+        cache.setCacheItem(`cart_product_${product.sku}`, product)
+
+        await this.calculateTotal()
+
+        loading.stopLoading()
+        const { show } = useNotification()
+        show({
+          type: 'success',
+          message: 'Product added to cart'
+        })
+      } catch (error) {
+        loading.stopLoading()
+        errorHandler.handle(error)
+      }
+    },
+
+    async removeItem(itemId: string) {
+      const loading = useLoading()
+      loading.startLoading('Removing item...')
+
+      try {
+        const auth = useAuth()
+        if (auth.isTokenExpired()) {
+          await auth.refreshAccessToken()
+        }
+
+        // Remove from Magento cart
+        const response = await fetch(
+          `${process.env.MAGENTO_API_URL}/carts/mine/items/${itemId}`,
+          {
+            method: 'DELETE',
+            headers: {
+              'Authorization': `Bearer ${auth.token.value}`
+            }
+          }
+        )
+
+        if (!response.ok) {
+          throw new CartError('Failed to remove item from cart', 'CART_ERROR')
+        }
+
+        // Update local cart state
+        this.items = this.items.filter(item => item.item_id !== itemId)
+        await this.calculateTotal()
+
+        loading.stopLoading()
+        useNotification().show({
+          type: 'success',
+          message: 'Item removed from cart'
+        })
+      } catch (error) {
+        loading.stopLoading()
+        errorHandler.handle(error)
+      }
+    },
+
+    async calculateTotal() {
+      try {
+        const auth = useAuth()
+        if (!this.quoteId) return
+
+        // Get cart totals from Magento
+        const response = await fetch(
+          `${process.env.MAGENTO_API_URL}/carts/mine/totals`,
+          {
+            headers: {
+              'Authorization': `Bearer ${auth.token.value}`
+            }
+          }
+        )
+
+        if (!response.ok) {
+          throw new CartError('Failed to get cart totals', 'CART_ERROR')
+        }
+
+        const totals = await response.json()
+        this.total = totals.grand_total
+      } catch (error) {
+        console.error('Error calculating totals:', error)
+        errorHandler.handle(error)
+      }
+    },
+
+    // Update other methods to use the notification composable
+    async clearCart() {
+      const loading = useLoading()
+      loading.startLoading('Clearing cart...')
+
+      try {
+        const auth = useAuth()
+        if (this.quoteId) {
+          const response = await fetch(`${process.env.MAGENTO_API_URL}/carts/mine/clear`, {
+            method: 'POST',
+            headers: {
+              'Authorization': `Bearer ${auth.token.value}`
+            }
+          })
+
+          if (!response.ok) {
+            throw new CartError('Failed to clear cart', 'CART_ERROR')
+          }
+        }
+        
+        this.items = []
+        this.total = 0
+        this.quoteId = null
+
+        // Clear cart-related cache
+        const cache = useCache()
+        this.items.forEach(item => {
+          cache.setCacheItem(`cart_product_${item.sku}`, null)
+        })
+
+        loading.stopLoading()
+        const { show } = useNotification()
+        show({
+          type: 'success',
+          message: 'Cart cleared successfully'
+        })
+      } catch (error) {
+        loading.stopLoading()
+        errorHandler.handle(error)
+      }
+    },
+
+    async syncCartWithMagento() {
+      try {
+        const auth = useAuth()
+        const response = await fetch(`${process.env.MAGENTO_API_URL}/carts/mine/items`, {
+          headers: {
+            'Authorization': `Bearer ${auth.token.value}`
+          }
+        })
+
+        if (!response.ok) {
+          throw new CartError('Failed to sync cart', 'CART_ERROR')
+        }
+
+        const magentoItems = await response.json()
+        this.items = magentoItems
+        await this.calculateTotal()
+      } catch (error) {
+        errorHandler.handle(error)
+      }
+    },
+
+    async validateCart() {
+      try {
+        // Check all items inventory
+        for (const item of this.items) {
+          const inventory = useInventory()
+          const isAvailable = await inventory.checkInventory(item.sku, item.qty)
+          if (!isAvailable) {
+            throw new CartError(`${item.name} is out of stock`, 'INVENTORY_ERROR')
+          }
+        }
+
+        // Validate prices
+        await this.syncCartWithMagento()
+
+        return true
+      } catch (error) {
+        errorHandler.handle(error)
+        return false
+      }
+    }
+  }
+})

package/app/composables/stores/checkout.ts

@@ -0,0 +1,19 @@
+import { defineStore } from 'pinia';
+import type { CheckoutState } from '@/types/checkout';
+
+export const useCheckoutStore = defineStore('checkout', {
+    state: (): CheckoutState => ({
+        shippingAddress: null,
+        paymentMethod: null,
+        orderId: '',
+        isLoading: false
+    }),
+    actions: {
+        setShippingAddress(address: string) {
+            this.shippingAddress = address;
+        },
+        setPaymentMethod(method: string) {
+            this.paymentMethod = method;
+        }
+    }
+});

package/app/composables/stores/compare.ts

@@ -0,0 +1,65 @@
+// stores/compare.ts
+import { defineStore } from 'pinia';
+import type {
+  ComparableAttribute,
+  ComparableItem,
+  ComparableProduct,
+  CompareList,
+} from '~/graphql/queries-mutations_subscriptions/types/ProductCompare.type';
+
+export const useCompareStore = defineStore('compare', {
+  state: () => ({
+    isLoading: false,
+    count: 0,
+    attributes: [] as ComparableAttribute[],
+    products: [] as ComparableProduct[],
+    productSkus: [] as string[],
+    items: [] as ComparableItem[]
+  }),
+
+  actions: {
+    toggleLoader(isLoading: boolean) {
+      this.isLoading = isLoading;
+    },
+
+    setCompareList(payload: CompareList) {
+      this.attributes = payload.attributes || [];
+      this.products = payload.products || [];
+      this.items = payload.items || [];
+    },
+
+    removeComparedProduct(productSku: string) {
+      this.products = this.products.filter(product => product.sku !== productSku);
+      this.productSkus = this.productSkus.filter(sku => sku !== productSku);
+      this.items = this.items.filter(item => item.product.sku !== productSku);
+    },
+
+    clearComparedProducts() {
+      this.products = [];
+      this.productSkus = [];
+      this.items = [];
+      this.count = 0;
+    },
+
+    setCompareListSkus(productSkus: string[]) {
+      this.productSkus = productSkus;
+    },
+
+    addComparedProductSku(productSku: string) {
+      if (!this.productSkus.includes(productSku)) {
+        this.productSkus.push(productSku);
+      }
+    },
+
+    updateCompareTotals(compareTotals: string) {
+      this.count = parseInt(compareTotals, 10); // Convert string to number
+    }
+  },
+
+  getters: {
+    getCompareCount: (state) => state.count,
+    getComparedProducts: (state) => state.products,
+    getComparedProductSkus: (state) => state.productSkus,
+    getIsLoading: (state) => state.isLoading
+  }
+});

package/app/composables/stores/currency.js

@@ -0,0 +1,29 @@
+import { defineStore } from 'pinia'
+
+export const useCurrencyStore = defineStore('currency', {
+  state: () => ({
+    currentCurrency: null,
+    exchangeRates: {}
+  }),
+
+  actions: {
+    setCurrency(currency) {
+      this.currentCurrency = currency
+    },
+
+    setExchangeRates(rates) {
+      this.exchangeRates = rates
+    },
+
+    async updateCurrency(currency) {
+      this.setCurrency(currency)
+      // Here you would typically make an API call to update the user's preference
+      // if they are logged in
+    }
+  },
+
+  getters: {
+    getCurrentCurrency: (state) => state.currentCurrency,
+    getExchangeRates: (state) => state.exchangeRates
+  }
+}) 

package/app/composables/stores/digital-products.js

@@ -0,0 +1,11 @@
+// stores/digital-products.js
+export const useDigitalProducts = defineStore('digital-products', {
+  state: () => ({
+    downloads: {},
+  }),
+  actions: {
+    downloadProduct(productId) {
+      // Download logic
+    },
+  },
+});

package/app/composables/stores/orders.ts

@@ -0,0 +1,161 @@
+// stores/orders.ts - Pinia store for order management
+import type { Order, Return, Transaction, Invoice, CreditMemo, OrderFilters } from '~/app/types'
+
+export const useOrdersStore = defineStore('orders', () => {
+  const orders = ref<Order[]>([])
+  const currentOrder = ref<Order | null>(null)
+  const returns = ref<Return[]>([])
+  const transactions = ref<Transaction[]>([])
+  const invoices = ref<Invoice[]>([])
+  const creditMemos = ref<CreditMemo[]>([])
+  const loading = ref(false)
+  const error = ref<string | null>(null)
+  
+  // Import composables
+  const { getOrders, getOrderById } = useOrders()
+  const { getReturns, createReturn } = useReturns()
+  const { getTransactions } = useTransactions()
+  const { getInvoices } = useInvoices()
+  const { getCreditMemos } = useCreditMemos()
+  
+  const fetchOrders = async (filters: OrderFilters = {}) => {
+    loading.value = true
+    error.value = null
+    try {
+      orders.value = await getOrders(filters)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error fetching orders:', err)
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const fetchOrder = async (id: string) => {
+    loading.value = true
+    error.value = null
+    try {
+      currentOrder.value = await getOrderById(id)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error fetching order:', err)
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const fetchReturns = async (options: { search?: string } = {}) => {
+    loading.value = true
+    error.value = null
+    try {
+      returns.value = await getReturns(options)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error fetching returns:', err)
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const submitReturn = async (returnData: any) => {
+    loading.value = true
+    error.value = null
+    try {
+      const newReturn = await createReturn(returnData)
+      returns.value.unshift(newReturn)
+      return newReturn
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error submitting return:', err)
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const fetchTransactions = async (options: { search?: string } = {}) => {
+    loading.value = true
+    error.value = null
+    try {
+      transactions.value = await getTransactions(options)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error fetching transactions:', err)
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const fetchInvoices = async (options: { search?: string } = {}) => {
+    loading.value = true
+    error.value = null
+    try {
+      invoices.value = await getInvoices(options)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error fetching invoices:', err)
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const fetchCreditMemos = async (options: { search?: string } = {}) => {
+    loading.value = true
+    error.value = null
+    try {
+      creditMemos.value = await getCreditMemos(options)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error fetching credit memos:', err)
+    } finally {
+      loading.value = false
+    }
+  }
+
+  // Computed properties
+  const ordersByStatus = computed(() => {
+    return orders.value.reduce((acc, order) => {
+      acc[order.status] = (acc[order.status] || 0) + 1
+      return acc
+    }, {} as Record<string, number>)
+  })
+
+  const totalRevenue = computed(() => {
+    return orders.value
+      .filter(order => !['cancelled', 'refunded'].includes(order.status))
+      .reduce((sum, order) => sum + order.total, 0)
+  })
+
+  const averageOrderValue = computed(() => {
+    const validOrders = orders.value.filter(order => 
+      !['cancelled', 'refunded'].includes(order.status)
+    )
+    return validOrders.length > 0 ? totalRevenue.value / validOrders.length : 0
+  })
+  
+  return {
+    // State
+    orders: readonly(orders),
+    currentOrder: readonly(currentOrder),
+    returns: readonly(returns),
+    transactions: readonly(transactions),
+    invoices: readonly(invoices),
+    creditMemos: readonly(creditMemos),
+    loading: readonly(loading),
+    error: readonly(error),
+    
+    // Computed
+    ordersByStatus,
+    totalRevenue,
+    averageOrderValue,
+    
+    // Actions
+    fetchOrders,
+    fetchOrder,
+    fetchReturns,
+    submitReturn,
+    fetchTransactions,
+    fetchInvoices,
+    fetchCreditMemos
+  }
+})

package/app/composables/stores/product.ts

@@ -0,0 +1,26 @@
+import { defineStore } from 'pinia';
+import type { Product, ProductState } from '@/types/product';
+
+export const useProductStore = defineStore('product', {
+    state: (): ProductState => ({
+        products: [],
+        selectedProduct: null,
+        isLoading: false
+    }),
+    actions: {
+        async fetchProducts() {
+            this.isLoading = true;
+            try {
+                const response = await $fetch<Product[]>('/api/products'); // Update API endpoint
+                this.products = response;
+            } catch (error) {
+                console.error('Error fetching products:', error);
+            } finally {
+                this.isLoading = false;
+            }
+        },
+        selectProduct(product: Product) {
+            this.selectedProduct = product;
+        }
+    }
+});