@meeovi/layer-commerce 1.0.11 → 1.0.14

package/app/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/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/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/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/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;
+        }
+    }
+});

package/app/stores/products.ts

@@ -0,0 +1,116 @@
+// stores/products.ts - Pinia store for product management
+import type { Product } from '~/app/types'
+import { defineStore } from 'pinia'
+import { ref, computed, readonly } from 'vue'
+import { useProducts } from '~/app/composables/products'
+import { useFeaturedProducts } from '~/app/composables/featured-products'
+
+export const useProductsStore = defineStore('products', () => {
+  const products = ref<Product[]>([])
+  const featuredProducts = ref<Product[]>([])
+  const currentProduct = ref<Product | null>(null)
+  const categories = ref([])
+  const loading = ref(false)
+  const error = ref<string | null>(null)
+  
+  // Import product composables
+  const { getProducts, getProductById, getProductsByCategory, searchProducts } = useProducts()
+  const { getFeaturedProducts } = useFeaturedProducts()
+  
+  const fetchProducts = async (options: any = {}) => {
+    loading.value = true
+    error.value = null
+    try {
+      products.value = await getProducts(options)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error fetching products:', err)
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const fetchProduct = async (id: string) => {
+    loading.value = true
+    error.value = null
+    try {
+      currentProduct.value = await getProductById(id)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error fetching product:', err)
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const fetchFeaturedProducts = async (options: any = {}) => {
+    loading.value = true
+    error.value = null
+    try {
+      featuredProducts.value = await getFeaturedProducts(options)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error fetching featured products:', err)
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const fetchProductsByCategory = async (categoryId: string, options: any = {}) => {
+    loading.value = true
+    error.value = null
+    try {
+      products.value = await getProductsByCategory(categoryId, options)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error fetching products by category:', err)
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const searchForProducts = async (query: string, options: any = {}) => {
+    loading.value = true
+    error.value = null
+    try {
+      products.value = await searchProducts(query, options)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error searching products:', err)
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  // Computed properties
+  const productsOnSale = computed(() => {
+    return products.value.filter(product => 
+      product.sale_price && product.sale_price < product.price
+    )
+  })
+  
+  const productCount = computed(() => {
+    return products.value.length
+  })
+  
+  return {
+    // State
+    products: readonly(products),
+    featuredProducts: readonly(featuredProducts),
+    currentProduct: readonly(currentProduct),
+    categories: readonly(categories),
+    loading: readonly(loading),
+    error: readonly(error),
+    
+    // Computed
+    productsOnSale,
+    productCount,
+    
+    // Actions
+    fetchProducts,
+    fetchProduct,
+    fetchFeaturedProducts,
+    fetchProductsByCategory,
+    searchForProducts
+  }
+})

package/app/stores/review.ts

@@ -0,0 +1,25 @@
+import { defineStore } from 'pinia';
+import type { Review, ReviewState } from '@/types/review';
+
+export const useReviewStore = defineStore('review', {
+    state: (): ReviewState => ({
+        reviews: [],
+        isLoading: false
+    }),
+    actions: {
+        async fetchReviews(productId: string) {
+            this.isLoading = true;
+            try {
+                const response = await $fetch<Review[]>(`/api/reviews?productId=${productId}`);
+                this.reviews = response;
+            } catch (error) {
+                console.error('Error fetching reviews:', error);
+            } finally {
+                this.isLoading = false;
+            }
+        },
+        addReview(review: Review) {
+            this.reviews.push(review);
+        }
+    }
+});

package/app/stores/storeInPickUp.ts

@@ -0,0 +1,22 @@
+import { defineStore } from 'pinia';
+import type { StorePickupState } from '@/types/storeInPickUp';
+
+export const useStoreInPickupStore = defineStore('storeInPickUp', {
+    state: (): StorePickupState => ({
+        selectedStoreId: null,
+        stores: []
+    }),
+    actions: {
+        setSelectedStore(storeId: string) {
+            this.selectedStoreId = storeId;
+        },
+        async fetchStores() {
+            try {
+                const response = await $fetch('/api/stores');
+                this.stores = response;
+            } catch (error) {
+                console.error('Error fetching stores:', error);
+            }
+        }
+    }
+});

package/app/stores/user.ts

@@ -0,0 +1,20 @@
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+
+export const useUserStore = defineStore('user', () => {
+  const user = ref<any>({});
+
+  function setUser(newUser: any) {
+    user.value = newUser;
+  }
+
+  function clearUser() {
+    user.value = {};
+  }
+
+  return {
+    user,
+    setUser,
+    clearUser,
+  };
+});

package/app/stores/wishlist.ts

@@ -0,0 +1,19 @@
+import { defineStore } from 'pinia';
+import type { WishlistState } from '@/types/wishlist';
+
+export const useWishlistStore = defineStore('wishlist', {
+    state: (): WishlistState => ({
+        items: [],
+        isLoading: false
+    }),
+    actions: {
+        addToWishlist(productId: string) {
+            if (!this.items.includes(productId)) {
+                this.items.push(productId);
+            }
+        },
+        removeFromWishlist(productId: string) {
+            this.items = this.items.filter(id => id !== productId);
+        }
+    }
+});

package/app/types/Order.type.ts

@@ -0,0 +1,181 @@
+// Order-specific types for the commerce layer
+export interface Order {
+  id: string
+  order_number: string
+  customer_id: string
+  company_id?: string
+  status: OrderStatusType
+  order_type?: 'standard' | 'purchase_order' | 'subscription'
+  
+  // Financial details
+  subtotal: number
+  tax_amount: number
+  shipping_amount: number
+  discount_amount: number
+  total: number
+  currency: string
+  
+  // Customer information
+  customer_name: string
+  customer_email: string
+  customer_phone?: string
+  
+  // Order items
+  order_items: OrderItem[]
+  
+  // Addresses
+  shipping_address?: Address
+  billing_address?: Address
+  
+  // Coupon/discount information
+  coupon_code?: string
+  coupon_id?: string
+  reward_points_used?: number
+  reward_discount_amount?: number
+  
+  // Purchase order details (B2B)
+  po_number?: string
+  po_reference?: string
+  
+  // Timestamps
+  created_at: string
+  updated_at: string
+  shipped_at?: string
+  delivered_at?: string
+  cancelled_at?: string
+}
+
+export interface OrderItem {
+  id: string
+  order_id: string
+  product_id: string
+  variant_id?: string
+  product_name: string
+  product_sku: string
+  quantity: number
+  price: number
+  total: number
+  product?: Product
+  variant?: ProductVariant
+}
+
+export interface Address {
+  id?: string
+  type?: 'shipping' | 'billing'
+  first_name: string
+  last_name: string
+  company?: string
+  street: string
+  street_2?: string
+  city: string
+  state: string
+  postal_code: string
+  country: string
+  phone?: string
+}
+
+export interface Product {
+  id: string
+  name: string
+  sku: string
+  price: number
+  sale_price?: number
+  description?: string
+  images?: ProductImage[]
+  inventory?: ProductInventory
+}
+
+export interface ProductVariant {
+  id: string
+  product_id: string
+  name: string
+  sku: string
+  price: number
+  attributes: Record<string, any>
+}
+
+export interface ProductImage {
+  id: string
+  url: string
+  alt_text?: string
+  sort_order?: number
+}
+
+export interface ProductInventory {
+  id: string
+  product_id: string
+  quantity: number
+  reserved_quantity?: number
+  available_quantity?: number
+}
+
+export type OrderStatusType = 
+  | 'draft'
+  | 'pending' 
+  | 'processing' 
+  | 'shipped' 
+  | 'delivered' 
+  | 'cancelled'
+  | 'refunded'
+  | 'on_hold'
+
+export interface OrderStatus {
+  status: 'success' | 'error' | 'partial'
+  message?: string
+  quantityAvailable?: number
+}
+
+export interface OrderMutationResult {
+  status: 'success' | 'error' | 'partial'
+  message?: string
+  order?: Order
+  quantityAvailable?: number
+}
+
+// Legacy types for backward compatibility
+export interface ActiveOrder extends Order {}
+
+// Order creation/update payloads
+export interface CreateOrderPayload {
+  customer_id?: string
+  company_id?: string
+  order_type?: 'standard' | 'purchase_order' | 'subscription'
+  shipping_address?: Partial<Address>
+  billing_address?: Partial<Address>
+  po_number?: string
+  notes?: string
+}
+
+export interface UpdateOrderPayload {
+  status?: OrderStatusType
+  shipping_address?: Partial<Address>
+  billing_address?: Partial<Address>
+  notes?: string
+  tracking_number?: string
+}
+
+// Order filters for queries
+export interface OrderFilters {
+  status?: OrderStatusType | OrderStatusType[]
+  customer_id?: string
+  company_id?: string
+  order_type?: string
+  date_from?: string
+  date_to?: string
+  search?: string
+  limit?: number
+  page?: number
+}
+
+// Order statistics
+export interface OrderStats {
+  total_orders: number
+  total_revenue: number
+  average_order_value: number
+  orders_by_status: Record<OrderStatusType, number>
+  revenue_by_period: Array<{
+    period: string
+    revenue: number
+    orders: number
+  }>
+}

package/app/types/checkout.ts

@@ -0,0 +1,6 @@
+export interface CheckoutState {
+  shippingAddress: string | null
+  paymentMethod: string | null
+  orderId: string
+  isLoading: boolean
+}