@meeovi/layer-commerce 1.0.10 → 1.0.13

package/app/composables/stores/products.ts

@@ -0,0 +1,112 @@
+// stores/products.ts - Pinia store for product management
+import type { Product } from '~/app/types'
+
+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/composables/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/composables/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/composables/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/composables/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/composables/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/composables/types/index.ts

@@ -0,0 +1,285 @@
+// types/index.ts - Main type definitions for commerce layer
+
+// Re-export Order types
+export * from './Order.type'
+export type Money = string | number;
+
+export interface VariationNode {
+  databaseId: number;
+  salePrice: Money;
+  regularPrice: Money;
+  stockQuantity?: number;
+  image?: { sourceUrl: string };
+}
+
+export interface Variation {
+  node: VariationNode;
+  attributes: Array<{ value: string }>;
+}
+
+export interface ProductNode {
+  sku: string;
+  slug: string;
+  name: string;
+}
+
+export interface Product {
+  id: string;
+  sku?: string;
+  slug?: string;
+  name?: string;
+  description?: string;
+  images?: Array<{ sourceUrl?: string }>;
+  price?: number;
+  regularPrice?: number;
+  salePrice?: number;
+  attributes?: Array<{ name: string; value: string }>;
+  variations?: ProductVariant[];
+}
+
+export interface ProductVariant {
+  id: string;
+  sku?: string;
+  price?: number;
+  regularPrice?: number;
+  salePrice?: number;
+  stockQuantity?: number;
+  image?: { sourceUrl?: string };
+  attributes?: Array<{ name: string; value: string }>;
+}
+
+export interface CartItemNode {
+  key: string;
+  quantity: number;
+  product: { node: ProductNode };
+  variation: Variation;
+}
+
+export interface AddToCartResponse {
+  addToCart: { cartItem: CartItemNode };
+}
+
+export type AddBtnStatus = 'add' | 'loading' | 'added';
+
+export type RemoveBtnStatus = 'remove' | 'loading';
+
+// Customer types
+export interface Customer {
+  id: string
+  first_name: string
+  last_name: string
+  email: string
+  phone?: string
+  date_of_birth?: string
+  preferred_currency?: string
+  company_id?: string
+  created_at: string
+  updated_at: string
+}
+
+// Company types (B2B)
+export interface Company {
+  id: string
+  name: string
+  email: string
+  phone?: string
+  tax_id?: string
+  industry?: string
+  owner_id: string
+  status: 'active' | 'inactive' | 'pending'
+  created_at: string
+  updated_at: string
+}
+
+// Return types
+export interface Refund {
+  id: string
+  refund_number?: string
+  order_id?: string
+  return_id?: string
+  transaction_id?: string
+  amount: number
+  currency: string
+  reason?: string
+  status: 'pending' | 'processed' | 'refunded' | 'failed' | 'cancelled'
+  metadata?: Record<string, any>
+  created_at: string
+  updated_at: string
+}
+
+export interface Return {
+  id: string
+  return_number: string
+  order_id: string
+  customer_id: string
+  status: 'requested' | 'approved' | 'rejected' | 'processed' | 'refunded'
+  reason: string
+  description?: string
+  return_items: ReturnItem[]
+  refunds?: Refund[]
+  created_at: string
+  updated_at: string
+}
+
+export interface ReturnItem {
+  id: string
+  return_id: string
+  order_item_id: string
+  product_id: string
+  quantity: number
+  reason: string
+  condition?: 'new' | 'used' | 'damaged'
+}
+
+// Transaction types
+export interface Transaction {
+  id: string
+  transaction_id: string
+  order_id?: string
+  customer_id?: string
+  type: 'payment' | 'refund' | 'authorization' | 'capture'
+  amount: number
+  currency: string
+  status: 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled'
+  payment_method: string
+  gateway_response?: Record<string, any>
+  created_at: string
+  updated_at: string
+}
+
+// Invoice types
+export interface Invoice {
+  id: string
+  invoice_number: string
+  order_id: string
+  customer_id: string
+  amount: number
+  tax_amount: number
+  currency: string
+  due_date: string
+  status: 'draft' | 'sent' | 'paid' | 'overdue' | 'cancelled'
+  invoice_items: InvoiceItem[]
+  payments?: Payment[]
+  created_at: string
+  updated_at: string
+}
+
+export interface InvoiceItem {
+  id: string
+  invoice_id: string
+  product_id: string
+  description: string
+  quantity: number
+  unit_price: number
+  total: number
+}
+
+export interface Payment {
+  id: string
+  payment_number?: string
+  invoice_id?: string
+  order_id?: string
+  customer_id?: string
+  amount: number
+  currency: string
+  method: string
+  transaction_id?: string
+  status: 'pending' | 'completed' | 'failed' | 'refunded' | 'cancelled'
+  gateway_response?: Record<string, any>
+  created_at: string
+  updated_at: string
+}
+
+// Credit Memo types
+export interface CreditMemo {
+  id: string
+  memo_number: string
+  order_id: string
+  return_id?: string
+  customer_id: string
+  amount: number
+  currency: string
+  reason: string
+  status: 'pending' | 'approved' | 'processed' | 'refunded' | 'cancelled'
+  memo_items: CreditMemoItem[]
+  created_at: string
+  updated_at: string
+}
+
+export interface CreditMemoItem {
+  id: string
+  memo_id: string
+  product_id: string
+  description: string
+  quantity: number
+  unit_price: number
+  total: number
+}
+
+// Cart types
+export interface Cart {
+  id: string
+  customer_id?: string
+  session_id?: string
+  items: CartItem[]
+  subtotal: number
+  tax_amount: number
+  shipping_amount: number
+  discount_amount: number
+  total: number
+  currency: string
+  coupon_code?: string
+  created_at: string
+  updated_at: string
+}
+
+export interface CartItem {
+  id: string
+  cart_id: string
+  product_id: string
+  variant_id?: string
+  quantity: number
+  price: number
+  total: number
+  product?: Product
+  variant?: ProductVariant
+}
+
+// Coupon types
+export interface Coupon {
+  id: string
+  code: string
+  name: string
+  description?: string
+  discount_type: 'percentage' | 'fixed_amount'
+  discount_value: number
+  minimum_amount?: number
+  maximum_discount?: number
+  usage_limit?: number
+  usage_count: number
+  usage_limit_per_customer?: number
+  valid_from?: string
+  valid_until?: string
+  status: 'active' | 'inactive' | 'expired'
+  created_at: string
+}
+
+// Common utility types
+export interface PaginationMeta {
+  current_page: number
+  per_page: number
+  total: number
+  total_pages: number
+}
+
+export interface ApiResponse<T> {
+  data: T
+  meta?: PaginationMeta
+  message?: string
+}
+
+export interface ApiError {
+  message: string
+  code?: string
+  details?: Record<string, any>
+}

package/app/composables/types/product.ts

@@ -0,0 +1,14 @@
+export interface Product {
+  id: string;
+  name: string;
+  price: number;
+  image?: string;
+  description?: string;
+  sku: string;
+}
+
+export interface ProductState {
+  products: Product[];
+  selectedProduct?: Product | null;
+  isLoading: boolean;
+}

package/app/composables/useBreakpoints/index.ts

@@ -0,0 +1 @@
+export * from './useBreakpoints';

package/app/composables/useBreakpoints/useBreakpoints.ts

@@ -0,0 +1,28 @@
+import { ref, onMounted } from 'vue';
+import { createSharedComposable, syncRefs, useBreakpoints as useBreakpointsVueUse } from '@vueuse/core';
+
+/**
+ * @description Composable that prepares breakpoints-dependent refs
+ * @returns {@link ReturnType<typeof useBreakpoints>}
+ * @example
+ * const { isTablet, isDesktop } = useBreakpoints();
+ */
+export const useBreakpoints = createSharedComposable(() => {
+  const breakpoints = useBreakpointsVueUse({
+    tablet: '768px',
+    desktop: '1024px',
+  });
+
+  const isTablet = ref(true);
+  const isDesktop = ref(false);
+
+  onMounted(() => {
+    syncRefs(breakpoints.greaterOrEqual('tablet'), isTablet);
+    syncRefs(breakpoints.greaterOrEqual('desktop'), isDesktop);
+  });
+
+  return {
+    isTablet,
+    isDesktop,
+  };
+});