@meeovi/layer-commerce 1.0.11 → 1.0.14

package/app/types/imports.d.ts

@@ -0,0 +1,28 @@
+declare module '#imports' {
+  export function useRuntimeConfig(): any
+  export function useNuxtApp(): any
+  export function useAppConfig(): any
+  export function useOrders(): any
+  export function useReturns(): any
+  export function useTransactions(): any
+  export function useInvoices(): any
+  export function useCreditMemos(): any
+}
+
+declare module 'nuxt/app' {
+  export function useAppConfig(): any
+  export function useAsyncData<T = any>(keyOrHandler: string | null | (() => Promise<T> | T), handler?: (...args: any[]) => Promise<T> | T): Promise<{ data: { value: T }, error: { value: any } }>
+  export function useState<T = any>(key: string, init?: T | (() => T)): { value: T }
+}
+
+// Provide globals for files that call Nuxt auto-imports without module import
+declare function useNuxtApp(): any
+declare function useRuntimeConfig(): any
+declare function useAppConfig(): any
+
+// Order-related auto-imports used without explicit imports in stores
+declare function useOrders(): any
+declare function useReturns(): any
+declare function useTransactions(): any
+declare function useInvoices(): any
+declare function useCreditMemos(): any

package/app/types/index.ts

@@ -0,0 +1,291 @@
+export * from '~/types/checkout'
+export * from '~/types/product'
+export * from '~/types/review'
+export * from '~/types/storeInPickUp'
+export * from '~/types/wishlist'
+// 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;
+  sale_price?: 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/types/nuxt-imports.d.ts

@@ -0,0 +1,5 @@
+declare module '#imports' {
+  import { Ref } from 'vue'
+  export function useNuxtApp(): any
+  export function useAsyncData<T = any>(key?: string | symbol, handler?: () => Promise<T> | T): { data: Ref<T | undefined> }
+}

package/app/types/product-state.ts

@@ -0,0 +1,8 @@
+import type { SimpleProduct } from './product'
+
+export interface ProductState {
+  products: SimpleProduct[]
+  selectedProduct: SimpleProduct | null
+  isLoading: boolean
+  error?: string | null
+}

package/app/types/product.ts

@@ -0,0 +1,22 @@
+export interface Price {
+  value: number
+  currency: string
+}
+
+export interface ProductVariant {
+  id: string
+  sku?: string
+  price?: Price
+  attributes?: Record<string, any>
+}
+
+export interface SimpleProduct {
+  id: string
+  title?: string
+  description?: string
+  images?: string[]
+  price?: Price
+  variants?: ProductVariant[]
+}
+export * from './index'
+export type { ProductState } from './product-state'

package/app/types/review-state.ts

@@ -0,0 +1,7 @@
+import type { Review } from './review'
+
+export interface ReviewState {
+  reviews: Review[]
+  isLoading: boolean
+  error?: string | null
+}

package/app/types/review.ts

@@ -0,0 +1,2 @@
+export interface Review { id: string; productId: string; rating: number; comment?: string; author?: string }
+export type { ReviewState } from './review-state'

package/app/types/storeInPickUp.ts

@@ -0,0 +1,2 @@
+export interface StoreInPickUp { id: string; name: string; address: string; phone?: string }
+export type { StorePickupState } from './storePickup-state'

package/app/types/storePickup-state.ts

@@ -0,0 +1,5 @@
+export interface StorePickupState {
+  selectedStoreId: string | null
+  stores: any[]
+  error?: string | null
+}

package/app/types/vue-globals.d.ts

@@ -0,0 +1,9 @@
+// Minimal ambient declarations for Vue/Pinia globals used in the commerce layer
+declare function ref<T = any>(value?: T): any
+declare function computed<T = any>(fn: () => T): any
+declare function readonly<T = any>(v: T): T
+declare function reactive<T = any>(v: T): T
+declare function watchEffect(fn: () => void): void
+
+// Pinia-ish defineStore (layers may call defineStore during build time)
+declare function defineStore(id: string, setup: any): any

package/app/types/wishlist-state.ts

@@ -0,0 +1,5 @@
+export interface WishlistState {
+  items: any[]
+  isLoading: boolean
+  error?: string | null
+}

package/app/types/wishlist.ts

@@ -0,0 +1,2 @@
+export interface WishlistItem { id: string; productSku: string; addedAt: string }
+export type { WishlistState } from './wishlist-state'

package/app/utils/client.ts

@@ -0,0 +1,26 @@
+import * as CommercePkg from '#imports';
+import { sdk } from '@meeovi/sdk';
+
+const CommerceAny: any = CommercePkg as any;
+
+/**
+ * Returns a commerce client. Prefer `@meeovi/commerce` client creation APIs
+ * when available, otherwise fall back to `sdk.commerce`.
+ */
+export function getCommerceClient(provider?: string, providerConfig?: any) {
+  try {
+    if (typeof CommerceAny.createClient === 'function') {
+      return CommerceAny.createClient(provider, providerConfig);
+    }
+    if (typeof CommerceAny.init === 'function') {
+      return CommerceAny.init(providerConfig);
+    }
+  } catch (e) {
+    // swallow and fallback to sdk
+  }
+
+  // fallback: return the SDK's commerce helper (already used in many composables)
+  return sdk.commerce;
+}
+
+export default getCommerceClient;

package/app/utils/countryList.ts

@@ -0,0 +1,14 @@
+// ISO 3166-1 country codes and names (short sample, extend as needed)
+export default [
+  { code: 'US', name: 'United States' },
+  { code: 'CA', name: 'Canada' },
+  { code: 'GB', name: 'United Kingdom' },
+  { code: 'DE', name: 'Germany' },
+  { code: 'FR', name: 'France' },
+  { code: 'IT', name: 'Italy' },
+  { code: 'ES', name: 'Spain' },
+  { code: 'AU', name: 'Australia' },
+  { code: 'JP', name: 'Japan' },
+  { code: 'CN', name: 'China' },
+  // ...add more as needed
+];

package/app/utils/currency.js

@@ -0,0 +1,56 @@
+/**
+ * Format a price amount according to the given currency
+ * @param {number} amount - The price amount to format
+ * @param {string} currency - The currency code (e.g., 'USD', 'EUR')
+ * @param {Object} exchangeRates - Object containing exchange rates
+ * @returns {string} Formatted price string
+ */
+export const formatPrice = (amount, currency, exchangeRates) => {
+  if (!amount || !currency) return ''
+  
+  const rate = exchangeRates[currency] || 1
+  const convertedAmount = amount * rate
+
+  return new Intl.NumberFormat(undefined, {
+    style: 'currency',
+    currency: currency
+  }).format(convertedAmount)
+}
+
+/**
+ * Convert price from one currency to another
+ * @param {number} amount - The price amount to convert
+ * @param {string} fromCurrency - Source currency code
+ * @param {string} toCurrency - Target currency code
+ * @param {Object} exchangeRates - Object containing exchange rates
+ * @returns {number} Converted price amount
+ */
+export const convertPrice = (amount, fromCurrency, toCurrency, exchangeRates) => {
+  if (!amount || !fromCurrency || !toCurrency || !exchangeRates) return amount
+  
+  const fromRate = exchangeRates[fromCurrency] || 1
+  const toRate = exchangeRates[toCurrency] || 1
+  
+  return (amount * toRate) / fromRate
+}
+
+/**
+ * Get currency symbol for a currency code
+ * @param {string} code - Currency code
+ * @returns {string} Currency symbol
+ */
+export const getCurrencySymbol = (code) => {
+  const symbols = {
+    USD: '$',
+    EUR: '€',
+    GBP: '£',
+    JPY: '¥',
+    AUD: 'A$',
+    CAD: 'C$',
+    CHF: 'CHF',
+    CNY: '¥',
+    INR: '₹',
+    // Add more currency symbols as needed
+  }
+  return symbols[code] || code
+} 

package/app/utils/errorHandler.ts

@@ -0,0 +1,16 @@
+export const errorHandler = {
+  handle(err: unknown) {
+    // Structured handling: log and optionally rethrow
+    try {
+      if (err instanceof Error) {
+        console.error(`[Commerce][Error] ${err.name}: ${err.message}`)
+      } else {
+        console.error('[Commerce][Error]', err)
+      }
+    } catch (e) {
+      console.error('Error while handling error', e)
+    }
+  }
+}
+
+export default errorHandler

package/app/utils/index.ts

@@ -0,0 +1,53 @@
+import { NormalizerRegistry, CommerceNormalizer } from './normalizer';
+
+// Keep imports loose because host `@meeovi/commerce` implementations may vary
+import * as CommercePkg from '#imports';
+const CommerceAny: any = CommercePkg as any;
+
+export type Provider = string;
+
+export interface CommerceLayerConfig {
+  provider: Provider;
+  providerConfig?: Record<string, any>;
+  normalizer?: CommerceNormalizer;
+  registry?: NormalizerRegistry;
+}
+
+export function createCommerceLayer(config: CommerceLayerConfig) {
+  const registry = config.registry ?? new NormalizerRegistry();
+  const normalizer = config.normalizer ?? registry.get(config.provider);
+
+  if (!normalizer) {
+    throw new Error('No normalizer found for provider: ' + config.provider);
+  }
+
+  // Create or obtain a client from `@meeovi/commerce` in a resilient way
+  const client = ((): any => {
+    try {
+      if (typeof CommerceAny.createClient === 'function') {
+        return CommerceAny.createClient(config.provider, config.providerConfig);
+      }
+      if (typeof CommerceAny.init === 'function') {
+        return CommerceAny.init(config.providerConfig);
+      }
+      return CommerceAny;
+    } catch (e) {
+      // In production, surface useful message while avoiding leaking secrets
+      throw new Error('Failed to initialize commerce client for provider: ' + config.provider);
+    }
+  })();
+
+  async function getProduct(id: string) {
+    const raw = await (client.getProduct?.(id) ?? client.fetchProduct?.(id) ?? client.product?.(id));
+    return normalizer!.normalizeProduct(raw);
+  }
+
+  return {
+    client,
+    getProduct,
+    registry,
+    normalizer,
+  } as const;
+}
+
+export default createCommerceLayer;

package/app/utils/normalizer.ts

@@ -0,0 +1,23 @@
+export interface CommerceNormalizer {
+  normalizeProduct(data: any): any;
+  normalizeCategory?(data: any): any;
+  normalizeCart?(data: any): any;
+}
+
+export class NormalizerRegistry {
+  private registry = new Map<string, CommerceNormalizer>();
+
+  register(name: string, normalizer: CommerceNormalizer) {
+    this.registry.set(name, normalizer);
+  }
+
+  get(name: string): CommerceNormalizer | undefined {
+    return this.registry.get(name);
+  }
+
+  list(): string[] {
+    return Array.from(this.registry.keys());
+  }
+}
+
+export default NormalizerRegistry;

package/app/utils/normalizers/magento.ts

@@ -0,0 +1,29 @@
+import { CommerceNormalizer } from "../normalizer";
+
+export const magentoNormalizer: CommerceNormalizer = {
+  normalizeProduct(data: any) {
+    return {
+      id: data?.id ?? data?.sku ?? data?.item_id,
+      title: data?.name ?? data?.title,
+      price:
+        data?.price ?? data?.price_range?.minimum_price?.final_price?.value,
+      description: data?.description ?? data?.short_description,
+      images: (data?.media_gallery_entries ?? []).map((m: any) => m.file || m.url),
+      raw: data,
+    };
+  },
+
+  normalizeCategory(data: any) {
+    return {
+      id: data?.id,
+      name: data?.name,
+      raw: data,
+    };
+  },
+
+  normalizeCart(data: any) {
+    return { raw: data };
+  },
+};
+
+export default magentoNormalizer;

package/app/utils/normalizers/shopify.ts

@@ -0,0 +1,29 @@
+import { CommerceNormalizer } from "../normalizer";
+
+export const shopifyNormalizer: CommerceNormalizer = {
+  normalizeProduct(data: any) {
+    // Shopify payloads vary depending on SDK; this maps common fields
+    return {
+      id: data?.id ?? data?.variants?.[0]?.id,
+      title: data?.title ?? data?.name,
+      price: data?.variants?.[0]?.price ?? data?.price,
+      description: data?.body_html ?? data?.description,
+      images: (data?.images ?? []).map((i: any) => i?.src || i?.url),
+      raw: data,
+    };
+  },
+
+  normalizeCategory(data: any) {
+    return {
+      id: data?.id,
+      name: data?.title ?? data?.name,
+      raw: data,
+    };
+  },
+
+  normalizeCart(data: any) {
+    return { raw: data };
+  },
+};
+
+export default shopifyNormalizer;

package/app/utils/stripe.ts

@@ -0,0 +1,16 @@
+// utils/stripe.ts
+import { loadStripe, type Stripe } from '@stripe/stripe-js';
+
+let stripePromise: Promise<Stripe | null> | null = null;
+
+/**
+ * Returns a Stripe instance (singleton per publishable key)
+ * @param {string} publishableKey - Your Stripe publishable key
+ * @returns {Promise<Stripe | null>}
+ */
+export function getStripe(publishableKey: string): Promise<Stripe | null> {
+  if (!stripePromise) {
+    stripePromise = loadStripe(publishableKey);
+  }
+  return stripePromise;
+}