@mframework/layer-commerce 0.0.3

package/app/stores/Product/Product.dispatcher.ts

@@ -0,0 +1,53 @@
+import { getCommerceClient } from '../../utils/client'
+
+// Product dispatcher that uses the normalized commerce client when available.
+export async function fetchProductById(id: string): Promise<any | null> {
+  try {
+    const client = getCommerceClient()
+    if (client) {
+      if (typeof client.getProductById === 'function') return await client.getProductById(id)
+      if (typeof client.getProduct === 'function') return await client.getProduct(id)
+      if (typeof client.getProducts === 'function') {
+        const list = await client.getProducts({ ids: [id] })
+        return Array.isArray(list) ? list.find((p: any) => p.id === id || p.sku === id) ?? null : null
+      }
+    }
+  } catch (e) {
+    console.error('fetchProductById failed:', e)
+  }
+  return null
+}
+
+export async function fetchProductVariants(productId: string): Promise<any[]> {
+  try {
+    const client = getCommerceClient()
+    if (client && typeof client.getProductVariants === 'function') {
+      return await client.getProductVariants(productId)
+    }
+  } catch (e) {
+    console.error('fetchProductVariants failed:', e)
+  }
+  return []
+}
+
+export async function handleData(dispatch: any, options: any) {
+  // If a preload system passes a dispatch function and product id, load product and dispatch
+  try {
+    if (typeof dispatch === 'function' && options && options.id) {
+      const product = await fetchProductById(options.id)
+      dispatch({ type: 'PRODUCT_LOADED', payload: product })
+      return product
+    }
+  } catch (e) {
+    // ignore
+  }
+  return null
+}
+
+const _default = {
+  fetchProductById,
+  fetchProductVariants,
+  handleData,
+}
+
+export default _default

package/app/stores/Product/Product.reducer.ts

@@ -0,0 +1,12 @@
+// Minimal Product reducer compatibility layer. Responds to `PRODUCT_LOADED`.
+export default function ProductReducer(state = { product: null }, action: any) {
+  if (!action) return state
+  try {
+    if (action.type === 'PRODUCT_LOADED') {
+      return { ...state, product: action.payload }
+    }
+  } catch (e) {
+    // ignore and return current state
+  }
+  return state
+}

package/app/stores/ProductList/ProductList.dispatcher.ts

@@ -0,0 +1,35 @@
+import { getCommerceClient } from '../../utils/client'
+
+// ProductList dispatcher that prefers the normalized commerce client when
+// available. Returns an array of normalized products or an empty array.
+export async function fetchProductList(params: any = {}): Promise<any[]> {
+  const client = getCommerceClient()
+  try {
+    if (client) {
+      if (typeof client.listProducts === 'function') {
+        return await client.listProducts(params)
+      }
+      if (typeof client.getProducts === 'function') {
+        return await client.getProducts(params)
+      }
+    }
+  } catch (e) {
+    console.error('fetchProductList failed:', e)
+  }
+  return []
+}
+
+export async function handleData(dispatch: any, options: any) {
+  const data = await fetchProductList(options)
+  if (typeof dispatch === 'function') {
+    try {
+      dispatch({ type: 'PRODUCT_LIST_LOADED', payload: data })
+    } catch (e) {
+      // best-effort: ignore dispatch errors
+    }
+  }
+  return data
+}
+
+const _default = { fetchProductList, handleData }
+export default _default

package/app/stores/ProductList/ProductList.reducer.ts

@@ -0,0 +1,13 @@
+// Minimal ProductList reducer compatibility layer. Accepts an action with
+// `type: 'PRODUCT_LIST_LOADED'` and `payload` to populate `items`.
+export default function ProductListReducer(state = { items: [] }, action: any) {
+  if (!action) return state
+  try {
+    if (action.type === 'PRODUCT_LIST_LOADED') {
+      return { ...state, items: Array.isArray(action.payload) ? action.payload : state.items }
+    }
+  } catch (e) {
+    // ignore and return current state
+  }
+  return state
+}

package/app/stores/Store.type.ts

@@ -0,0 +1,31 @@
+// Minimal RootState shim to satisfy legacy reducer shape references.
+// Keep it permissive: callers may rely on additional keys at runtime.
+export interface ConfigReducerState {
+  countries?: any[]
+  base_link_url?: string
+  secure_base_media_url?: string
+  base_url?: string
+  [key: string]: any
+}
+
+export interface CartReducerState {
+  cart?: any
+  items?: any[]
+  totals?: any
+  [key: string]: any
+}
+
+export interface MyAccountReducerState {
+  customer?: any
+  signedIn?: boolean
+  [key: string]: any
+}
+
+export interface RootState {
+  ConfigReducer?: ConfigReducerState
+  CartReducer?: CartReducerState
+  MyAccountReducer?: MyAccountReducerState
+  [key: string]: any
+}
+
+// Named interface `RootState` exported above; no additional export statement needed.

package/app/stores/Wishlist/Wishlist.type.ts

@@ -0,0 +1,12 @@
+export interface WishlistProduct {
+  id: string
+  sku?: string
+  name?: string
+  price?: number
+  qty?: number
+  [key: string]: any
+}
+
+export interface WishlistState {
+  items: WishlistProduct[]
+}

package/app/stores/cart.ts

@@ -0,0 +1,218 @@
+import { ref, computed, readonly } from 'vue'
+import type { Cart as DomainCart } from '../types/domain'
+import { useCart } from '../cart/useCart'
+import { defineStore } from 'pinia'
+
+export const useCartStore = defineStore('cart', () => {
+  const cart = ref<DomainCart | null>(null)
+  const loading = ref(false)
+  const error = ref<string | null>(null)
+  
+  // Import cart composable
+  const { 
+    fetchCart, 
+    addToCart, 
+    removeFromCart, 
+    updateCartItem, 
+    applyCoupon, 
+    removeCoupon, 
+    clearCart,
+    setShippingOption: setShippingOptionFn
+    ,createCheckoutSession: createCheckoutSessionFn
+  } = useCart() as any
+  
+  const initializeCart = async () => {
+    loading.value = true
+    error.value = null
+    try {
+      await fetchCart()
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error initializing cart:', err)
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const addProductToCart = async (productId: string, quantity: number = 1, variantId?: string) => {
+    loading.value = true
+    error.value = null
+    try {
+      await addToCart(productId, quantity, variantId)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error adding product to cart:', err)
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const removeProductFromCart = async (itemId: string) => {
+    loading.value = true
+    error.value = null
+    try {
+      await removeFromCart(itemId)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error removing product from cart:', err)
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const updateProductQuantity = async (itemId: string, quantity: number) => {
+    loading.value = true
+    error.value = null
+    try {
+      await updateCartItem(itemId, quantity)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error updating cart item:', err)
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const applyCartCoupon = async (couponCode: string) => {
+    loading.value = true
+    error.value = null
+    try {
+      const success = await applyCoupon(couponCode)
+      if (!success) {
+        throw new Error('Failed to apply coupon')
+      }
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error applying coupon:', err)
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const removeCartCoupon = async () => {
+    loading.value = true
+    error.value = null
+    try {
+      await removeCoupon()
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error removing coupon:', err)
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  const emptyCart = async () => {
+    loading.value = true
+    error.value = null
+    try {
+      await clearCart()
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error clearing cart:', err)
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+
+  const setShippingOption = async (option: any) => {
+    loading.value = true
+    error.value = null
+    try {
+      if (!setShippingOptionFn) throw new Error('Shipping setter unavailable')
+      await setShippingOptionFn(option)
+    } catch (err: any) {
+      error.value = err.message
+      console.error('Error setting shipping option:', err)
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+
+  const createCheckoutSession = async (cartId?: string) => {
+    loading.value = true
+    error.value = null
+    try {
+      const data = await createCheckoutSessionFn(cartId)
+      return data
+    } catch (err: any) {
+      error.value = err.message
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+  
+  // Computed properties
+  const itemCount = computed(() => {
+    return cart.value?.items?.reduce((count: number, item: any) => count + (item?.quantity ?? 0), 0) || 0
+  })
+  
+  const isEmpty = computed(() => {
+    return !cart.value?.items?.length
+  })
+  
+  const hasItems = computed(() => {
+    return !isEmpty.value
+  })
+  
+  const subtotal = computed(() => {
+    return (cart.value?.prices?.subtotal?.value ?? (cart.value as any)?.subtotal ?? 0) as number
+  })
+
+  const total = computed(() => {
+    return (cart.value?.prices?.grand_total?.value ?? (cart.value as any)?.total ?? 0) as number
+  })
+
+  const taxAmount = computed(() => {
+    return (cart.value?.prices?.tax?.value ?? (cart.value as any)?.tax_amount ?? 0) as number
+  })
+
+  const shippingAmount = computed(() => {
+    return (cart.value?.prices?.shipping?.value ?? (cart.value as any)?.shipping_amount ?? 0) as number
+  })
+
+  const discountAmount = computed(() => {
+    return (cart.value?.prices?.discounts?.value ?? (cart.value as any)?.discount_amount ?? 0) as number
+  })
+  
+  const hasCoupon = computed(() => {
+    return !!(cart.value as any)?.coupon_code
+  })
+  
+  return {
+    // State
+    cart: readonly(cart),
+    loading: readonly(loading),
+    error: readonly(error),
+    
+    // Computed
+    itemCount,
+    isEmpty,
+    hasItems,
+    subtotal,
+    total,
+    taxAmount,
+    shippingAmount,
+    discountAmount,
+    hasCoupon,
+    
+    // Actions
+    initializeCart,
+    addProductToCart,
+    removeProductFromCart,
+    updateProductQuantity,
+    applyCartCoupon,
+    removeCartCoupon,
+    emptyCart
+    ,setShippingOption
+    ,createCheckoutSession
+  }
+})

package/app/stores/cartStore.ts

@@ -0,0 +1,224 @@
+// stores/cartStore.ts
+import { defineStore } from 'pinia'
+import { getCommerceClient } from '../utils/client'
+import { useAuth } from '../composables/useAuth'
+import { useInventory } from '../composables/useInventory'
+import { useTax } from '../composables/useTax'
+import { useLoading } from '../composables/useLoading'
+import { useNotification } from '../composables/useNotification'
+import { useCache } from '../composables/useCache'
+
+class CartError extends Error {
+  code: string
+  constructor(message: string, code: string) {
+    super(message)
+    this.code = code
+    this.name = 'CartError'
+  }
+}
+
+interface CartProduct {
+  sku: string
+  name?: string
+  price?: number
+  qty: number
+  quote_id?: string
+  item_id?: string
+}
+
+export const useCartStore = defineStore('cart', {
+  state: () => ({
+    isGuest: true,
+    items: [] as CartProduct[],
+    total: 0,
+    quoteId: null as string | null,
+    client: getCommerceClient()
+  }),
+
+  actions: {
+    async initializeCart() {
+      const auth = useAuth()
+      this.isGuest = !auth.token.value
+      try {
+        if (this.isGuest) await this.createGuestCart()
+        else await this.createCustomerCart()
+      } catch (err) {
+        console.error(err)
+      }
+    },
+
+    async createGuestCart() {
+      try {
+        if (this.client && typeof this.client.createGuestCart === 'function') {
+          this.quoteId = await this.client.createGuestCart()
+          return
+        }
+        const response = await fetch(`${process.env.MAGENTO_API_URL}/guest-carts`, { method: 'POST' })
+        this.quoteId = (await response.json()) as string
+      } catch (err) {
+        console.error(err)
+      }
+    },
+
+    async createCustomerCart() {
+      try {
+        const auth = useAuth()
+        if (this.client && typeof this.client.createCustomerCart === 'function') {
+          this.quoteId = await this.client.createCustomerCart(auth.token?.value)
+          return
+        }
+        const response = await fetch(`${process.env.MAGENTO_API_URL}/carts/mine`, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${auth.token.value}` }
+        })
+        this.quoteId = await response.json()
+      } catch (err) {
+        console.error(err)
+      }
+    },
+
+    async addItem(product: CartProduct) {
+      const loading = useLoading()
+      loading.startLoading('Adding to cart...')
+      try {
+        const auth = useAuth()
+        if (auth.isTokenExpired()) await auth.refreshAccessToken()
+        const inventory = useInventory()
+        await inventory.checkInventory(product.sku, product.qty)
+        if (!this.quoteId) await this.initializeCart()
+        if (!this.quoteId) throw new CartError('Failed to create cart', 'CART_ERROR')
+
+        if (this.client && typeof this.client.addItem === 'function') {
+          const cartItem = await this.client.addItem(this.quoteId, product, auth.token?.value)
+          const existing = this.items.find(i => i.sku === product.sku)
+          if (existing) existing.qty += product.qty
+          else this.items.push({ ...product, item_id: cartItem?.item_id })
+        } else {
+          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()
+          const existing = this.items.find(i => i.sku === product.sku)
+          if (existing) existing.qty += product.qty
+          else this.items.push({ ...product, item_id: cartItem.item_id })
+        }
+
+        const tax = useTax()
+        if (this.quoteId) await tax.calculateTax(this.quoteId)
+        const cache = useCache()
+        cache.setCacheItem(`cart_product_${product.sku}`, product)
+        await this.calculateTotal()
+        loading.stopLoading()
+        useNotification().show({ type: 'success', message: 'Product added to cart' })
+      } catch (err) {
+        loading.stopLoading()
+        console.error(err)
+      }
+    },
+
+    async removeItem(itemId: string) {
+      const loading = useLoading()
+      loading.startLoading('Removing item...')
+      try {
+        const auth = useAuth()
+        if (auth.isTokenExpired()) await auth.refreshAccessToken()
+
+        if (this.client && typeof this.client.removeItem === 'function') {
+          await this.client.removeItem(this.quoteId, itemId, auth.token?.value)
+          this.items = this.items.filter(i => i.item_id !== itemId)
+          await this.calculateTotal()
+        } else {
+          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')
+          this.items = this.items.filter(i => i.item_id !== itemId)
+          await this.calculateTotal()
+        }
+
+        loading.stopLoading()
+        useNotification().show({ type: 'success', message: 'Item removed from cart' })
+      } catch (err) {
+        loading.stopLoading()
+        console.error(err)
+      }
+    },
+
+    async calculateTotal() {
+      try {
+        const auth = useAuth()
+        if (!this.quoteId) return
+        if (this.client && typeof this.client.getTotals === 'function') {
+          const totals = await this.client.getTotals(this.quoteId, auth.token?.value)
+          this.total = totals?.grand_total || 0
+          return
+        }
+        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 (err) {
+        console.error('Error calculating totals:', err)
+      }
+    },
+
+    async clearCart() {
+      const loading = useLoading()
+      loading.startLoading('Clearing cart...')
+      try {
+        const auth = useAuth()
+        if (this.quoteId) {
+          if (this.client && typeof this.client.clearCart === 'function') {
+            await this.client.clearCart(this.quoteId, auth.token?.value)
+          } else {
+            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
+        const cache = useCache()
+        this.items.forEach(item => cache.setCacheItem(`cart_product_${item.sku}`, null))
+        loading.stopLoading()
+        useNotification().show({ type: 'success', message: 'Cart cleared successfully' })
+      } catch (err) {
+        loading.stopLoading()
+        console.error(err)
+      }
+    },
+
+    async syncCartWithMagento() {
+      try {
+        const auth = useAuth()
+        if (this.client && typeof this.client.listItems === 'function') {
+          this.items = await this.client.listItems(this.quoteId, auth.token?.value)
+          await this.calculateTotal()
+          return
+        }
+        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')
+        this.items = await response.json()
+        await this.calculateTotal()
+      } catch (err) {
+        console.error(err)
+      }
+    },
+
+    async validateCart() {
+      try {
+        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')
+        }
+        await this.syncCartWithMagento()
+        return true
+      } catch (err) {
+        console.error(err)
+        return false
+      }
+    }
+  }
+})

package/app/stores/checkout.ts

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

package/app/stores/compare.ts

@@ -0,0 +1,65 @@
+// stores/compare.ts
+import { defineStore } from 'pinia';
+import type {
+  ComparableAttribute,
+  ComparableItem,
+  ComparableProduct,
+  CompareList,
+} from '~/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: any) => product.sku !== productSku);
+      this.productSkus = this.productSkus.filter((sku: string) => sku !== productSku);
+      this.items = this.items.filter((item: any) => 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
+  }
+});