@meeovi/layer-commerce 1.0.3 → 1.0.5

package/dist/composables/models/shared.d.ts

@@ -0,0 +1,66 @@
+import type { InferCustom } from "../defs";
+export type Maybe<TType> = TType | null;
+export type SfId = string;
+export interface SfMoneyCustom extends InferCustom<"normalizeMoney"> {
+}
+export interface SfMoney {
+    currency: string;
+    amount: number;
+    precisionAmount: string;
+    $custom?: SfMoneyCustom;
+}
+export interface SfDiscountablePriceCustom extends InferCustom<"normalizeDiscountablePrice"> {
+}
+export interface SfDiscountablePrice {
+    isDiscounted: boolean;
+    regularPrice: SfMoney;
+    /**
+     * Price with discounts. If there is no discount, it will be the same as regularPrice
+     */
+    value: SfMoney;
+    $custom?: SfDiscountablePriceCustom;
+}
+export interface SfImageCustom extends InferCustom<"normalizeImage"> {
+}
+export interface SfImage {
+    alt: Maybe<string>;
+    url: string;
+    $custom?: SfImageCustom;
+}
+export interface SfAttributeCustom extends InferCustom<"normalizeAttribute"> {
+}
+export interface SfAttribute {
+    label: string;
+    name: string;
+    value: string;
+    valueLabel: string;
+    $custom?: SfAttributeCustom;
+}
+export interface SfCreateAddressBody {
+    address1: string;
+    address2?: Maybe<string>;
+    city: string;
+    country: string;
+    firstName: string;
+    lastName: string;
+    phoneNumber: string;
+    postalCode: string;
+    state: string;
+    titleCode: string;
+}
+export interface SfAddressCustom extends InferCustom<"normalizeAddress"> {
+}
+export interface SfAddress {
+    address1: Maybe<string>;
+    address2?: Maybe<string>;
+    city: Maybe<string>;
+    country: Maybe<string>;
+    firstName: Maybe<string>;
+    lastName: Maybe<string>;
+    phoneNumber: Maybe<string>;
+    postalCode: Maybe<string>;
+    state: Maybe<string>;
+    titleCode: Maybe<string>;
+    $custom?: SfAddressCustom;
+}
+export type SfCurrency = string;

package/dist/composables/models/shared.js

@@ -0,0 +1 @@
+export {};

package/dist/composables/products/registry.d.ts

@@ -0,0 +1,4 @@
+import { ProductProvider } from "./types";
+export declare function registerProductProvider(name: string, provider: ProductProvider): void;
+export declare function getProductProvider(name: string): ProductProvider;
+export declare function registerProductProviderRuntime(name: string, provider: ProductProvider): void;

package/dist/composables/products/registry.js

@@ -0,0 +1,16 @@
+const providers = {};
+export function registerProductProvider(name, provider) {
+    providers[name] = provider;
+}
+export function getProductProvider(name) {
+    const provider = providers[name];
+    if (!provider)
+        throw new Error(`Product provider "${name}" not found`);
+    return provider;
+}
+// Runtime helper for adapter packages to register themselves when the
+// app boots. Adapter packages can import this and call it from their
+// plugin entry to wire into the commerce product provider registry.
+export function registerProductProviderRuntime(name, provider) {
+    registerProductProvider(name, provider);
+}

package/dist/composables/products/types.d.ts

@@ -0,0 +1,12 @@
+export interface Product {
+    id: string;
+    title: string;
+    description?: string;
+    price: number;
+    images: string[];
+    [key: string]: any;
+}
+export interface ProductProvider {
+    getProduct(id: string): Promise<Product>;
+    listProducts(params?: Record<string, any>): Promise<Product[]>;
+}

package/dist/composables/products/types.js

@@ -0,0 +1 @@
+export {};

package/dist/composables/products/useProducts.d.ts

@@ -0,0 +1,4 @@
+export declare function useProducts(): {
+    getProduct: (id: string) => Promise<import("./types").Product>;
+    listProducts: (params?: Record<string, any>) => Promise<import("./types").Product[]>;
+};

package/dist/composables/products/useProducts.js

@@ -0,0 +1,10 @@
+import { getCommerceConfig } from '../config';
+import { getProductProvider } from './registry';
+export function useProducts() {
+    const { productProvider } = getCommerceConfig();
+    const provider = getProductProvider(productProvider);
+    return {
+        getProduct: provider.getProduct,
+        listProducts: provider.listProducts
+    };
+}

package/dist/composables/registry.d.ts

@@ -0,0 +1,9 @@
+import type { ProductProvider } from './products/types';
+import type { CartProvider } from './cart/types';
+export interface CommerceProviderBundle {
+    product?: ProductProvider;
+    cart?: CartProvider;
+}
+export declare function registerCommerceProviderRuntime(name: string, bundle: CommerceProviderBundle): void;
+export { registerProductProviderRuntime } from './products/registry';
+export { registerCartProviderRuntime } from './cart/registry';

package/dist/composables/registry.js

@@ -0,0 +1,13 @@
+import { registerProductProvider } from './products/registry';
+import { registerCartProvider } from './cart/registry';
+// Register multiple domain providers at once from an adapter package.
+// Example adapter entrypoint can call this during app boot.
+export function registerCommerceProviderRuntime(name, bundle) {
+    if (bundle.product)
+        registerProductProvider(name, bundle.product);
+    if (bundle.cart)
+        registerCartProvider(name, bundle.cart);
+}
+// Also re-export individual runtime helpers for convenience
+export { registerProductProviderRuntime } from './products/registry';
+export { registerCartProviderRuntime } from './cart/registry';

package/dist/composables/stores/cart.d.ts

@@ -0,0 +1 @@
+export declare const useCartStore: any;

package/dist/composables/stores/cart.js

@@ -0,0 +1,203 @@
+import { ref, computed, readonly } from 'vue';
+import { useCart } from '../cart/useCart';
+import { defineStore } from 'pinia';
+export const useCartStore = defineStore('cart', () => {
+    const cart = ref(null);
+    const loading = ref(false);
+    const error = ref(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) {
+            error.value = err.message;
+            console.error('Error initializing cart:', err);
+        }
+        finally {
+            loading.value = false;
+        }
+    };
+    const addProductToCart = async (productId, quantity = 1, variantId) => {
+        loading.value = true;
+        error.value = null;
+        try {
+            await addToCart(productId, quantity, variantId);
+        }
+        catch (err) {
+            error.value = err.message;
+            console.error('Error adding product to cart:', err);
+            throw err;
+        }
+        finally {
+            loading.value = false;
+        }
+    };
+    const removeProductFromCart = async (itemId) => {
+        loading.value = true;
+        error.value = null;
+        try {
+            await removeFromCart(itemId);
+        }
+        catch (err) {
+            error.value = err.message;
+            console.error('Error removing product from cart:', err);
+            throw err;
+        }
+        finally {
+            loading.value = false;
+        }
+    };
+    const updateProductQuantity = async (itemId, quantity) => {
+        loading.value = true;
+        error.value = null;
+        try {
+            await updateCartItem(itemId, quantity);
+        }
+        catch (err) {
+            error.value = err.message;
+            console.error('Error updating cart item:', err);
+            throw err;
+        }
+        finally {
+            loading.value = false;
+        }
+    };
+    const applyCartCoupon = async (couponCode) => {
+        loading.value = true;
+        error.value = null;
+        try {
+            const success = await applyCoupon(couponCode);
+            if (!success) {
+                throw new Error('Failed to apply coupon');
+            }
+        }
+        catch (err) {
+            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) {
+            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) {
+            error.value = err.message;
+            console.error('Error clearing cart:', err);
+            throw err;
+        }
+        finally {
+            loading.value = false;
+        }
+    };
+    const setShippingOption = async (option) => {
+        loading.value = true;
+        error.value = null;
+        try {
+            if (!setShippingOptionFn)
+                throw new Error('Shipping setter unavailable');
+            await setShippingOptionFn(option);
+        }
+        catch (err) {
+            error.value = err.message;
+            console.error('Error setting shipping option:', err);
+            throw err;
+        }
+        finally {
+            loading.value = false;
+        }
+    };
+    const createCheckoutSession = async (cartId) => {
+        loading.value = true;
+        error.value = null;
+        try {
+            const data = await createCheckoutSessionFn(cartId);
+            return data;
+        }
+        catch (err) {
+            error.value = err.message;
+            throw err;
+        }
+        finally {
+            loading.value = false;
+        }
+    };
+    // Computed properties
+    const itemCount = computed(() => {
+        return cart.value?.items?.reduce((count, item) => 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/dist/composables/stores/cartStore.d.ts

@@ -0,0 +1 @@
+export declare const useCartStore: any;

package/dist/composables/stores/cartStore.js

@@ -0,0 +1,246 @@
+// stores/cartStore.ts
+import { defineStore } from 'pinia';
+import { MagentoService } from '~/services/magento';
+export const useCartStore = defineStore('cart', {
+    state: () => ({
+        isGuest: true,
+        items: [],
+        total: 0,
+        quoteId: 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;
+        },
+        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) {
+            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) {
+            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/dist/composables/stores/checkout.d.ts

@@ -0,0 +1 @@
+export declare const useCheckoutStore: any;

package/dist/composables/stores/checkout.js

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

package/dist/composables/stores/compare.d.ts

@@ -0,0 +1 @@
+export declare const useCompareStore: any;