@kasuvia/sdk 0.0.2 → 0.0.4

package/src/hooks/use-cart.ts

@@ -2,13 +2,14 @@
  * Cart Hook & Context Provider
  *
  * React Query hooks for cart operations with unified drawer state sharing.
+ * config and accessToken are optional — if omitted, they are read from SdkContext.
  */
 import React, { createContext, useContext, useState, type ReactNode } from 'react'
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
 import { getCart, addToCart, updateCartItem, removeFromCart, clearCart, mergeGuestCartIfPresent } from '../services/cart.service'
-import { isInitialized } from '../config'
 import type { CartItem, CartResponse, Product } from '../types/store'
-import axios from 'axios'
+import type { SdkConfig } from '../config'
+import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
 
 interface ProductTypeMismatchDetail {
   code?: string
@@ -41,7 +42,7 @@ export interface UseCartReturn {
   removeFromCart: (itemId: string) => void
   clearCart: () => void
   clear: () => void
-  mergeGuestCart: () => void
+  mergeGuestCart: (guestSessionId: string) => void
   addItem: (product: Product, variantId?: string, quantity?: number, customMeasurements?: Record<string, string>) => void
   updateQty: (itemId: string, quantity: number) => void
   removeItem: (itemId: string) => void
@@ -72,136 +73,238 @@ export function CartProvider({ children }: { children: ReactNode }) {
 
 // ── Hook ──────────────────────────────────────────────────────────────────────
 
-export function useCart(): UseCartReturn {
-  const queryClient = useQueryClient()
-  const context = CartCtx ? useContext(CartCtx) : null
+export function useCart(config?: SdkConfig, accessToken?: string | null): UseCartReturn {
+  const ctx = useSdkContext();
+  try {
+    const resolved = resolveHookArgs(config, accessToken, ctx);
+    const resolvedConfig = resolved.config;
+    const resolvedToken = resolved.accessToken;
+    const queryClient = useQueryClient()
+    const context = CartCtx ? useContext(CartCtx) : null
 
-  const isOpen = context ? context.isOpen : false
-  const setOpen = context ? context.setOpen : () => {}
+    const isOpen = context ? context.isOpen : false
+    const setOpen = context ? context.setOpen : () => {}
 
-  // Track product type mismatch errors from cart operations
-  const [productTypeMismatch, setProductTypeMismatch] = useState<{
-    message: string
-    existing_type: string
-    new_type: string
-  } | null>(null)
-
-  const cartQuery = useQuery({
-    queryKey: ['cart'],
-    queryFn: getCart,
-    enabled: isInitialized(),
-  })
-
-  const addToCartMutation = useMutation({
-    mutationFn: addToCart,
-    onSuccess: () => {
-      setProductTypeMismatch(null) // Clear error on success
-      queryClient.invalidateQueries({ queryKey: ['cart'] })
-    },
-    onError: (error: unknown) => {
-      // Handle product type mismatch errors from backend
-      if (axios.isAxiosError(error) && error.response?.status === 409) {
-        const responseData = error.response?.data as { detail?: ProductTypeMismatchDetail } | undefined
-        const errorDetail = responseData?.detail
-        if (errorDetail?.code === 'CART_PRODUCT_TYPE_MISMATCH') {
+    // Track product type mismatch errors from cart operations
+    const [productTypeMismatch, setProductTypeMismatch] = useState<{
+      message: string
+      existing_type: string
+      new_type: string
+    } | null>(null)
+
+    const cartQuery = useQuery({
+      queryKey: ['cart'],
+      queryFn: async () => {
+        if (resolvedToken) {
+          return getCart(resolvedConfig, resolvedToken)
+        }
+        if (typeof window !== 'undefined') {
+          const res = await fetch('/api/cart', { credentials: 'include' })
+          if (!res.ok) throw new Error('Failed to fetch cart')
+          return res.json()
+        }
+        return undefined
+      },
+      enabled: true,
+    })
+
+    const addToCartMutation = useMutation({
+      mutationFn: async (item: Parameters<typeof addToCart>[2]) => {
+        if (resolvedToken) {
+          return addToCart(resolvedConfig, resolvedToken, item)
+        }
+        if (typeof window !== 'undefined') {
+          const res = await fetch('/api/cart', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            credentials: 'include',
+            body: JSON.stringify(item),
+          })
+          if (!res.ok) {
+            const data = await res.json().catch(() => ({}))
+            throw { status: res.status, data }
+          }
+          return res.json()
+        }
+        throw new Error('No access token and not in browser context')
+      },
+      onSuccess: () => {
+        setProductTypeMismatch(null)
+        queryClient.invalidateQueries({ queryKey: ['cart'] })
+      },
+      onError: (error: unknown) => {
+        // Handle product type mismatch errors from backend
+        const err = error as { status?: number; data?: { detail?: ProductTypeMismatchDetail } }
+        if (err.status === 409 && err.data?.detail?.code === 'CART_PRODUCT_TYPE_MISMATCH') {
+          const errorDetail = err.data.detail
           setProductTypeMismatch({
             message: errorDetail.message ?? 'Your cart contains incompatible items.',
             existing_type: errorDetail.existing_type ?? 'physical',
             new_type: errorDetail.new_type ?? 'physical',
           })
         }
-      }
-    },
-  })
-
-  const updateCartItemMutation = useMutation({
-    mutationFn: ({ itemId, quantity }: { itemId: string; quantity: number }) =>
-      updateCartItem(itemId, quantity),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['cart'] })
-    },
-  })
-
-  const removeFromCartMutation = useMutation({
-    mutationFn: removeFromCart,
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['cart'] })
-    },
-  })
-
-  const clearCartMutation = useMutation({
-    mutationFn: clearCart,
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['cart'] })
-    },
-  })
-
-  const mergeGuestCartMutation = useMutation({
-    mutationFn: mergeGuestCartIfPresent,
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['cart'] })
-    },
-  })
-
-  // Convenience method for adding items with product object
-  const addItem = (product: Product, variantId?: string, quantity: number = 1, customMeasurements?: Record<string, string>) => {
-    const variant = variantId ? product.variants.find(v => v.id === variantId) : undefined
-    return addToCartMutation.mutate({
-      product_id: product.id,
-      product_slug: product.slug,
-      product_name: product.name,
-      image: product.images[0]?.url,
-      variant_id: variantId,
-      variant_attributes: variant?.attributes ? JSON.stringify(variant.attributes) : undefined,
-      unit_price: variant?.price ?? product.base_price,
-      quantity,
-      custom_measurements: customMeasurements ? JSON.stringify(customMeasurements) : undefined,
-      is_bespoke: product.is_bespoke,
+      },
     })
-  }
 
-  // Helper methods for storefront compatibility
-  const items = cartQuery.data?.items || []
-  const subtotal = cartQuery.data?.subtotal || 0
-  const count = items.reduce((total, item) => total + item.quantity, 0)
+    const updateCartItemMutation = useMutation({
+      mutationFn: async ({ itemId, quantity }: { itemId: string; quantity: number }) => {
+        if (resolvedToken) {
+          return updateCartItem(resolvedConfig, resolvedToken, itemId, quantity)
+        }
+        if (typeof window !== 'undefined') {
+          const res = await fetch(`/api/cart/${itemId}`, {
+            method: 'PATCH',
+            headers: { 'Content-Type': 'application/json' },
+            credentials: 'include',
+            body: JSON.stringify({ quantity }),
+          })
+          if (!res.ok) throw new Error('Failed to update cart item')
+          return res.json()
+        }
+        throw new Error('No access token')
+      },
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ['cart'] })
+      },
+    })
 
-  const updateQty = (itemId: string, quantity: number) => {
-    updateCartItemMutation.mutate({ itemId, quantity })
-  }
+    const removeFromCartMutation = useMutation({
+      mutationFn: async (itemId: string) => {
+        if (resolvedToken) {
+          return removeFromCart(resolvedConfig, resolvedToken, itemId)
+        }
+        if (typeof window !== 'undefined') {
+          const res = await fetch(`/api/cart/${itemId}`, {
+            method: 'DELETE',
+            credentials: 'include',
+          })
+          if (!res.ok) throw new Error('Failed to remove cart item')
+          return res.json()
+        }
+        throw new Error('No access token')
+      },
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ['cart'] })
+      },
+    })
 
-  const removeItem = (itemId: string) => {
-    removeFromCartMutation.mutate(itemId)
-  }
+    const clearCartMutation = useMutation({
+      mutationFn: async () => {
+        if (resolvedToken) {
+          return clearCart(resolvedConfig, resolvedToken)
+        }
+        if (typeof window !== 'undefined') {
+          const res = await fetch('/api/cart/clear', {
+            method: 'DELETE',
+            credentials: 'include',
+          })
+          if (!res.ok) throw new Error('Failed to clear cart')
+          return res.json()
+        }
+        throw new Error('No access token')
+      },
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ['cart'] })
+      },
+    })
 
-  const handleClearCartAndAdd = () => {
-    clearCartMutation.mutate()
-    setProductTypeMismatch(null)
-  }
+    const mergeGuestCartMutation = useMutation({
+      mutationFn: (guestSessionId: string) =>
+        resolvedToken ? mergeGuestCartIfPresent(resolvedConfig, resolvedToken, guestSessionId) : Promise.resolve(),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ['cart'] })
+      },
+    })
 
-  const handleKeepCurrentCart = () => {
-    setProductTypeMismatch(null)
-  }
+    // Convenience method for adding items with product object
+    const addItem = (product: Product, variantId?: string, quantity: number = 1, customMeasurements?: Record<string, string>) => {
+      const variant = variantId ? product.variants.find(v => v.id === variantId) : undefined
+      return addToCartMutation.mutate({
+        product_id: product.id,
+        product_slug: product.slug,
+        product_name: product.name,
+        image: product.images[0] || undefined,
+        variant_id: variantId,
+        variant_attributes: variant?.attributes ? JSON.stringify(variant.attributes) : undefined,
+        unit_price: variant?.price ?? product.base_price,
+        quantity,
+        custom_measurements: customMeasurements ? JSON.stringify(customMeasurements) : undefined,
+        is_bespoke: product.is_bespoke,
+      })
+    }
+
+    // Helper methods for storefront compatibility
+    const items = cartQuery.data?.items || []
+    const subtotal = cartQuery.data?.subtotal || 0
+    const count = items.reduce((total: number, item: CartItem) => total + item.quantity, 0)
+
+    const updateQty = (itemId: string, quantity: number) => {
+      updateCartItemMutation.mutate({ itemId, quantity })
+    }
+
+    const removeItem = (itemId: string) => {
+      removeFromCartMutation.mutate(itemId)
+    }
+
+    const handleClearCartAndAdd = () => {
+      clearCartMutation.mutate()
+      setProductTypeMismatch(null)
+    }
+
+    const handleKeepCurrentCart = () => {
+      setProductTypeMismatch(null)
+    }
 
-  return {
-    cart: cartQuery.data,
-    items,
-    count,
-    isOpen,
-    setOpen,
-    isLoading: cartQuery.isLoading,
-    error: cartQuery.error,
-    addToCart: addToCartMutation.mutate,
-    updateCartItem: updateCartItemMutation.mutate,
-    removeFromCart: removeFromCartMutation.mutate,
-    clearCart: clearCartMutation.mutate,
-    clear: clearCartMutation.mutate, // Alias for storefront compatibility
-    mergeGuestCart: mergeGuestCartMutation.mutate,
-    addItem,
-    updateQty,
-    removeItem,
-    subtotal,
-    productTypeMismatch,
-    handleClearCartAndAdd,
-    handleKeepCurrentCart,
+    return {
+      cart: cartQuery.data,
+      items,
+      count,
+      isOpen,
+      setOpen,
+      isLoading: cartQuery.isLoading,
+      error: cartQuery.error,
+      addToCart: addToCartMutation.mutate,
+      updateCartItem: updateCartItemMutation.mutate,
+      removeFromCart: removeFromCartMutation.mutate,
+      clearCart: clearCartMutation.mutate,
+      clear: clearCartMutation.mutate, // Alias for storefront compatibility
+      mergeGuestCart: mergeGuestCartMutation.mutate,
+      addItem,
+      updateQty,
+      removeItem,
+      subtotal,
+      productTypeMismatch,
+      handleClearCartAndAdd,
+      handleKeepCurrentCart,
+    }
+  } catch (error) {
+    // If called outside QueryClientProvider, return safe fallback
+    console.warn('[useCart] Called outside QueryClientProvider, returning empty cart')
+    const context = CartCtx ? useContext(CartCtx) : null
+    const isOpen = context ? context.isOpen : false
+    const setOpen = context ? context.setOpen : () => {}
+    
+    return {
+      cart: undefined,
+      items: [],
+      count: 0,
+      isOpen,
+      setOpen,
+      isLoading: false,
+      error: null,
+      addToCart: () => {},
+      updateCartItem: () => {},
+      removeFromCart: () => {},
+      clearCart: () => {},
+      clear: () => {},
+      mergeGuestCart: () => {},
+      addItem: () => {},
+      updateQty: () => {},
+      removeItem: () => {},
+      subtotal: 0,
+      productTypeMismatch: null,
+      handleClearCartAndAdd: () => {},
+      handleKeepCurrentCart: () => {},
+    } as any
   }
 }