@meeovi/commerce 1.0.0 → 1.0.2

package/README.md

@@ -0,0 +1,66 @@
+# @meeovi/commerce
+
+A backend‑agnostic commerce domain module for the Meeovi ecosystem.  
+This package provides a unified interface for products, categories, carts, and other commerce operations — regardless of the underlying backend (Directus, Medusa, Shopify, custom APIs, etc.).
+
+## ✨ Features
+
+- Pluggable provider architecture  
+- Unified composables (`useProducts`, `useCart`, `useCategories`)  
+- Backend‑agnostic types  
+- Runtime configuration  
+- Zero Nuxt dependency  
+- Works in any JS/TS environment  
+
+## 📦 Installation
+
+```sh
+npm install @meeovi/commerce
+
+⚙️ Configuration
+Configure the active providers at runtime:
+
+
+import { setCommerceConfig } from '@meeovi/commerce'
+
+setCommerceConfig({
+  productProvider: 'directus',
+  cartProvider: 'directus',
+  categoryProvider: 'directus'
+})
+
+🧩 Usage
+
+import { useProducts } from '@meeovi/commerce'
+
+const { listProducts, getProduct } = useProducts()
+
+const products = await listProducts()
+const product = await getProduct('123')
+🔌 Providers
+A provider implements one or more domain interfaces:
+
+
+export interface ProductProvider {
+  getProduct(id: string): Promise<Product>
+  listProducts(params?: any): Promise<Product[]>
+}
+Register a provider:
+
+
+import { registerProductProvider } from '@meeovi/commerce'
+
+registerProductProvider('directus', {
+  getProduct: async (id) => { ... },
+  listProducts: async () => { ... }
+})
+
+🧱 Folder Structure
+Code
+src/
+  products/
+  cart/
+  categories/
+  config.
+  registry.
+  useCommerce.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meeovi/commerce",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Commerce module for the M Framework.",
   "license": "ISC",
   "author": "Meeovi",
@@ -12,6 +12,8 @@
   "dependencies": {
     "@better-auth/stripe": "^1.4.15",
     "@polar-sh/better-auth": "^1.6.4",
-    "@polar-sh/sdk": "^0.42.2"
+    "@polar-sh/sdk": "^0.42.2",
+    "@storefront-ui/nuxt": "^3.1.1",
+    "@vue-storefront/unified-data-model": "^3.0.0"
   }
 }

package/src/stores/cart.ts

@@ -0,0 +1,218 @@
+import { ref, computed, readonly } from 'vue'
+import type { Cart, CartItem, Product } from '../types'
+import { useCart } from '../composables/cart/useCart'
+import { defineStore } from 'pinia'
+
+export const useCartStore = defineStore('cart', () => {
+  const cart = ref<Cart | 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()
+  
+  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: any, item: { quantity: any }) => count + item.quantity, 0) || 0
+  })
+  
+  const isEmpty = computed(() => {
+    return !cart.value?.items?.length
+  })
+  
+  const hasItems = computed(() => {
+    return !isEmpty.value
+  })
+  
+  const subtotal = computed(() => {
+    return cart.value?.subtotal || 0
+  })
+  
+  const total = computed(() => {
+    return cart.value?.total || 0
+  })
+  
+  const taxAmount = computed(() => {
+    return cart.value?.tax_amount || 0
+  })
+  
+  const shippingAmount = computed(() => {
+    return cart.value?.shipping_amount || 0
+  })
+  
+  const discountAmount = computed(() => {
+    return cart.value?.discount_amount || 0
+  })
+  
+  const hasCoupon = computed(() => {
+    return !!cart.value?.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/src/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/src/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/src/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/src/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
+  }
+})