@meeovi/layer-commerce 1.0.5 → 1.0.7

package/app/composables/stores/products.ts

@@ -1,112 +0,0 @@
-// 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

@@ -1,25 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,181 +0,0 @@
-// 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

@@ -1,285 +0,0 @@
-// 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

@@ -1,14 +0,0 @@
-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

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

package/app/composables/useBreakpoints/useBreakpoints.ts

@@ -1,28 +0,0 @@
-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,
-  };
-});