@mframework/layer-commerce 0.0.3

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,172 @@
+// stores/orders.ts - Pinia store for order management
+import { defineStore } from 'pinia'
+import { ref, computed, readonly } from 'vue'
+import { useOrders, useReturns, useTransactions, useInvoices, useCreditMemos } from '../composables/orders'
+import type { Order as DomainOrder, PaymentIntent as DomainPaymentIntent } from '../types/domain'
+
+type Order = DomainOrder
+type Return = DomainOrder
+type Transaction = DomainPaymentIntent
+type Invoice = DomainOrder
+type CreditMemo = DomainOrder
+type OrderFilters = any
+
+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: Record<string, number>, order: Order) => {
+      acc[order.status] = (acc[order.status] || 0) + 1
+      return acc
+    }, {} as Record<string, number>)
+  })
+
+  const totalRevenue = computed(() => {
+    const toNumber = (v: any) => (typeof v === 'number' ? v : (v?.value ?? 0))
+    return orders.value
+      .filter((order: Order) => !['cancelled', 'refunded'].includes(order?.status ?? ''))
+      .reduce((sum: number, order: Order) => sum + toNumber(order?.total), 0)
+  })
+
+  const averageOrderValue = computed(() => {
+    const validOrders = orders.value.filter((order: 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,34 @@
+import { defineStore } from 'pinia';
+import type { Product as DomainProduct } from '../types/domain';
+import { useProducts } from '../composables/products'
+
+interface ProductState {
+    products: DomainProduct[]
+    selectedProduct: DomainProduct | null
+    isLoading: boolean
+}
+
+export const useProductStore = defineStore('product', {
+    state: (): ProductState => ({
+        products: [],
+        selectedProduct: null,
+        isLoading: false
+    }),
+    actions: {
+        async fetchProducts(options: any = {}) {
+            this.isLoading = true;
+            try {
+                const { getProducts } = useProducts()
+                const response = await getProducts(options)
+                ;(this as any).products = response as DomainProduct[]
+            } catch (error) {
+                console.error('Error fetching products:', error);
+            } finally {
+                this.isLoading = false;
+            }
+        },
+        selectProduct(product: DomainProduct) {
+            ;(this as any).selectedProduct = product
+        }
+    }
+});

package/app/stores/productList.ts

@@ -0,0 +1,35 @@
+import { defineStore } from 'pinia'
+import { ref, computed, readonly } from 'vue'
+import type { Product as DomainProduct } from '../types/domain'
+import { useProducts } from '../composables/products'
+
+export const useProductListStore = defineStore('productList', () => {
+  const items = ref<DomainProduct[]>([])
+  const loading = ref(false)
+  const error = ref<string | null>(null)
+
+  const { getProducts } = useProducts()
+
+  const fetch = async (options: any = {}) => {
+    loading.value = true
+    error.value = null
+    try {
+      items.value = await getProducts(options)
+    } catch (err: any) {
+      error.value = err?.message ?? String(err)
+      console.error('Error fetching product list:', err)
+    } finally {
+      loading.value = false
+    }
+  }
+
+  const count = computed(() => items.value.length)
+
+  return {
+    items: readonly(items),
+    loading: readonly(loading),
+    error: readonly(error),
+    count,
+    fetch,
+  }
+})

package/app/stores/products.ts

@@ -0,0 +1,118 @@
+// stores/products.ts - Pinia store for product management
+import type { Product as DomainProduct } from '../types/domain'
+import { defineStore } from 'pinia'
+import { ref, computed, readonly } from 'vue'
+import { useProducts } from '../composables/products'
+import { useFeaturedProducts } from '../composables/featured-products'
+
+export const useProductsStore = defineStore('products', () => {
+  const products = ref<DomainProduct[]>([])
+  const featuredProducts = ref<DomainProduct[]>([])
+  const currentProduct = ref<DomainProduct | 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: DomainProduct) => {
+      if (product.sale_price == null) return false
+      const priceValue = (product as any).price?.value ?? (typeof (product as any).price === 'number' ? (product as any).price : undefined)
+      return priceValue != null && product.sale_price < priceValue
+    })
+  })
+  
+  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/recentlyViewedProducts.ts

@@ -0,0 +1,56 @@
+import { defineStore } from 'pinia'
+import { ref, readonly } from 'vue'
+import { getCommerceClient } from '../utils/client'
+import type { Product as DomainProduct } from '../types/domain'
+
+export const useRecentlyViewedStore = defineStore('recentlyViewed', () => {
+  const ids = ref<string[]>([])
+  const items = ref<DomainProduct[]>([])
+  const isLoading = ref(false)
+
+  const addViewed = (productId: string) => {
+    if (!ids.value.includes(productId)) {
+      ids.value.unshift(productId)
+      if (ids.value.length > 20) ids.value.pop()
+    }
+  }
+
+  const fetch = async () => {
+    isLoading.value = true
+    try {
+      const client = getCommerceClient()
+      if (client && typeof client.getProductById === 'function') {
+        const loaded: DomainProduct[] = []
+        for (const id of ids.value) {
+          try {
+            const p = await client.getProductById(id)
+            if (p) loaded.push(p)
+          } catch (e) {
+            // ignore per-item errors
+          }
+        }
+        items.value = loaded
+      } else if (ids.value.length) {
+        // Best-effort: try a bulk fetch if the client exposes it
+        try {
+          const clientAny: any = client
+          if (clientAny && typeof clientAny.getProducts === 'function') {
+            items.value = await clientAny.getProducts({ ids: ids.value })
+          }
+        } catch (e) {
+          // ignore
+        }
+      }
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  return {
+    ids: readonly(ids),
+    items: readonly(items),
+    isLoading: readonly(isLoading),
+    addViewed,
+    fetch,
+  }
+})

package/app/stores/review.ts

@@ -0,0 +1,33 @@
+import { defineStore } from 'pinia';
+import { getCommerceClient } from '../utils/client'
+import type { Review as DomainReview } from '../types/domain'
+
+type ReviewState = { reviews: DomainReview[]; isLoading: boolean }
+
+export const useReviewStore = defineStore('review', {
+    state: (): ReviewState => ({
+        reviews: [],
+        isLoading: false
+    }),
+    actions: {
+        async fetchReviews(productId: string) {
+            this.isLoading = true;
+            try {
+                const client = getCommerceClient()
+                if (client && typeof client.listReviews === 'function') {
+                    this.reviews = await client.listReviews({ productId }) as DomainReview[]
+                } else {
+                    const response = await $fetch<DomainReview[]>(`/api/reviews?productId=${productId}`);
+                    this.reviews = (response || []) as DomainReview[]
+                }
+            } catch (error) {
+                console.error('Error fetching reviews:', error);
+            } finally {
+                this.isLoading = false;
+            }
+        },
+        addReview(review: DomainReview) {
+            this.reviews.push(review);
+        }
+    }
+});

package/app/stores/storeInPickUp.ts

@@ -0,0 +1,21 @@
+import { defineStore } from 'pinia';
+
+export const useStoreInPickupStore = defineStore('storeInPickUp', {
+    state: (): { selectedStoreId: string | null; stores: any[] } => ({
+        selectedStoreId: null,
+        stores: []
+    }),
+    actions: {
+        setSelectedStore(storeId: string) {
+            this.selectedStoreId = storeId;
+        },
+        async fetchStores() {
+            try {
+                const response = await $fetch<any[]>('/api/stores');
+                this.stores = response as any[];
+            } 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,46 @@
+import { defineStore } from 'pinia';
+import { getCommerceClient } from '../utils/client'
+import type { Product as DomainProduct } from '../types/domain'
+
+type WishlistState = { items: string[]; isLoading: boolean; products: DomainProduct[] }
+
+export const useWishlistStore = defineStore('wishlist', {
+    state: (): WishlistState => ({
+        items: [],
+        isLoading: false,
+        products: []
+    }),
+    actions: {
+        addToWishlist(productId: string) {
+            if (!this.items.includes(productId)) {
+                this.items.push(productId);
+            }
+        },
+        removeFromWishlist(productId: string) {
+            this.items = this.items.filter((id: string) => id !== productId);
+            this.products = this.products.filter((p: any) => p.id !== productId && p.sku !== productId);
+        },
+        async fetchWishlistProducts() {
+            this.isLoading = true
+            try {
+                const client = getCommerceClient()
+                if (client && typeof client.getProducts === 'function') {
+                    this.products = await client.getProducts({ ids: this.items })
+                } else if (client && typeof client.getProductById === 'function') {
+                    const loaded: DomainProduct[] = []
+                    for (const id of this.items) {
+                        try {
+                            const p = await client.getProductById(id)
+                            if (p) loaded.push(p)
+                        } catch (e) {}
+                    }
+                    this.products = loaded
+                }
+            } catch (e) {
+                // ignore
+            } finally {
+                this.isLoading = false
+            }
+        }
+    }
+});