@kasuvia/sdk 0.0.8 → 0.0.9

package/src/hooks/use-cart.ts

@@ -2,22 +2,34 @@
  * 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.
+ * All cart operations route directly to kasuvia-cart-management via the SDK
+ * service functions — never through framework-coupled proxy routes.
+ *
+ * - Authenticated users: use Authorization Bearer token
+ * - Guest users:         use guestSessionId (X-Guest-Session header)
+ *
+ * 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 {
+  getCart,
+  getGuestCart,
+  addToCart,
+  addToGuestCart,
+  updateCartItem,
+  updateGuestCartItemQuantity,
+  removeFromCart,
+  removeFromGuestCart,
+  clearCart,
+  clearGuestCart,
+  mergeGuestCartIfPresent,
+} from '../services/cart.service'
+import { logger } from '../utils/logger'
 import type { CartItem, CartResponse, Product } from '../types/store'
 import type { SdkConfig } from '../config'
 import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
 
-interface ProductTypeMismatchDetail {
-  code?: string
-  message?: string
-  existing_type?: string
-  new_type?: string
-}
-
 export interface UseCartReturn {
   cart: CartResponse | undefined
   items: CartItem[]
@@ -28,15 +40,15 @@ export interface UseCartReturn {
   error: Error | null
   addToCart: (item: {
     product_id: string
-    product_slug: string
-    product_name: string
+    product_slug?: string
+    product_name?: string
     image?: string
     variant_id?: string
     variant_attributes?: string
-    unit_price: number
+    unit_price?: number
     quantity: number
     custom_measurements?: string
-    is_bespoke: boolean
+    is_bespoke?: boolean
   }) => void
   updateCartItem: (variables: { itemId: string; quantity: number }) => void
   removeFromCart: (itemId: string) => void
@@ -44,267 +56,327 @@ export interface UseCartReturn {
   clear: () => 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
+  /** Rejects with the real backend error on failure — the optimistic UI update it made is already rolled back by then; catch this to show why. */
+  updateQty: (itemId: string, quantity: number) => Promise<CartResponse>
+  /** Rejects with the real backend error on failure — the optimistic UI update it made is already rolled back by then; catch this to show why. */
+  removeItem: (itemId: string) => Promise<void>
   subtotal: number
-  productTypeMismatch: {
-    message: string
-    existing_type: string
-    new_type: string
-  } | null
+  productTypeMismatch: ProductTypeMismatchDetail | null
   handleClearCartAndAdd: () => void
   handleKeepCurrentCart: () => void
 }
 
 // ── React Context for Shared Drawer State ─────────────────────────────────────
 
+export interface ProductTypeMismatchDetail {
+  message: string
+  existing_type: string
+  new_type: string
+}
+
 export interface CartContextValue {
   isOpen: boolean
   setOpen: (open: boolean) => void
+  // REAL BUG FIXED (2026-09-24): this used to be a plain useState() local to
+  // every individual useCart() call - since each component invoking
+  // useCart() gets its own separate hook instance, a mismatch set by
+  // ProductDetailClient's addToCartMutation could never be seen by
+  // CartClient's own "keep cart or clear it" dialog (a different component,
+  // a different useCart() instance, a different local state). Lifted into
+  // this same shared context isOpen/setOpen already use, for the same
+  // reason: real cross-component cart state belongs here, not in a hook-
+  // local useState.
+  productTypeMismatch: ProductTypeMismatchDetail | null
+  setProductTypeMismatch: (detail: ProductTypeMismatchDetail | null) => void
 }
 
 export const CartCtx = React.createContext ? React.createContext<CartContextValue | null>(null) : null
 
 export function CartProvider({ children }: { children: ReactNode }) {
   const [isOpen, setIsOpen] = useState(false)
+  const [productTypeMismatch, setProductTypeMismatch] = useState<ProductTypeMismatchDetail | null>(null)
   if (!CartCtx) return children
-  return React.createElement(CartCtx.Provider, { value: { isOpen, setOpen: setIsOpen } }, children)
+  return React.createElement(CartCtx.Provider, { value: { isOpen, setOpen: setIsOpen, productTypeMismatch, setProductTypeMismatch } }, children)
 }
 
 // ── Hook ──────────────────────────────────────────────────────────────────────
 
-export function useCart(config?: SdkConfig, accessToken?: string | null): UseCartReturn {
+export function useCart(
+  config?: SdkConfig,
+  accessToken?: string | null,
+  guestSessionId?: 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 resolved = resolveHookArgs(config, accessToken, ctx);
+  const resolvedConfig = resolved.config;
+  const resolvedToken = resolved.accessToken;
+  // Falls back to SdkContext's guestSessionId (set by SdkProvider) when not
+  // passed explicitly — matches config/accessToken's own resolution pattern,
+  // so every real call site (none of which ever passed this explicitly) picks
+  // it up automatically. See utils/guest-session.ts for why this matters:
+  // without it, anonymous add-to-cart has never worked at all.
+  guestSessionId = guestSessionId !== undefined ? guestSessionId : (ctx?.guestSessionId ?? null)
+  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 : () => {}
+  // See CartContextValue's own doc comment: this must be context-shared
+  // (not a local useState) so the "keep cart or clear it" dialog on the
+  // cart page can actually see a mismatch that happened while adding from
+  // a product page - a different component, a different useCart() call.
+  const productTypeMismatch = context ? context.productTypeMismatch : null
+  const setProductTypeMismatch = context ? context.setProductTypeMismatch : () => {}
 
-    // Track product type mismatch errors from cart operations
-    const [productTypeMismatch, setProductTypeMismatch] = useState<{
-      message: string
-      existing_type: string
-      new_type: string
-    } | null>(null)
+  // Single source of truth for this identity's cart query key — every
+  // mutation's optimistic-update/rollback logic below targets this same key,
+  // so it must never be computed two different ways.
+  const cartQueryKey = ['cart', resolvedToken ?? guestSessionId ?? 'anon']
 
-    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,
-    })
+  // ── Cart Query ─────────────────────────────────────────────────────────────
+  // Authenticated → getCart(token)
+  // Guest         → getGuestCart(guestSessionId)
+  // No identity   → return empty cart (do not throw)
+  const cartQuery = useQuery({
+    queryKey: cartQueryKey,
+    queryFn: async (): Promise<CartResponse> => {
+      if (resolvedToken) {
+        return getCart(resolvedConfig, resolvedToken)
+      }
+      if (guestSessionId) {
+        return getGuestCart(resolvedConfig, guestSessionId)
+      }
+      // No identity — return an empty cart shape; caller can render an empty state.
+      return { items: [], subtotal: 0, total: 0, item_count: 0, product_type: undefined }
+    },
+    enabled: !!(resolvedToken || guestSessionId),
+  })
 
-    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',
-          })
-        }
-      },
-    })
+  // ── Add to Cart Mutation ──────────────────────────────────────────────────
+  const addToCartMutation = useMutation({
+    mutationFn: async (item: Parameters<typeof addToCart>[2]) => {
+      if (resolvedToken) {
+        return addToCart(resolvedConfig, resolvedToken, item)
+      }
+      if (guestSessionId) {
+        return addToGuestCart(resolvedConfig, guestSessionId, item)
+      }
+      throw new Error('Cannot add to cart: no access token or guest session ID provided.')
+    },
+    onSuccess: () => {
+      setProductTypeMismatch(null)
+      queryClient.invalidateQueries({ queryKey: ['cart'] })
+    },
+    // REAL BUG FIXED (2026-09-24), live-reported ("mixed products between
+    // physical to digital"): this read `error.status`/`error.data` - but
+    // apiRequest throws a real `ApiError` (utils/http-client.ts), whose
+    // fields are `.status`/`.body`/`.message`, not `.data` - `err.data` was
+    // always `undefined`, so this branch could never fire even when the
+    // backend genuinely sent a 409. Separately, kasuvia-cart-management's
+    // error body is a huma ErrorModel (`{detail: "plain string"}`), never a
+    // nested `{detail: {code, ...}}` object - this service's own
+    // TranslateServiceError doc comment already documents that convention
+    // (a bracketed "[CODE] ..." prefix in the message string, matching
+    // every other cart error). Parses that same convention here instead of
+    // a response shape the backend never produces.
+    onError: (error: unknown) => {
+      const err = error as { status?: number; message?: string }
+      if (err.status !== 409 || !err.message?.startsWith('[CART_PRODUCT_TYPE_MISMATCH]')) return
+      const match = err.message.match(/contains (\w+) items\. Add (\w+) items/i)
+      setProductTypeMismatch({
+        message: err.message.replace(/^\[CART_PRODUCT_TYPE_MISMATCH\]\s*/, ''),
+        existing_type: match?.[1] ?? 'unknown',
+        new_type: match?.[2] ?? 'unknown',
+      })
+    },
+  })
 
-    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'] })
-      },
-    })
+  // Recomputes subtotal/total/item_count for a locally-mutated items array —
+  // mirrors kasuvia-cart-management's own BuildResponse exactly (Total ===
+  // Subtotal at the cart stage; delivery/tax are only added at checkout).
+  // Deliberately does NOT recompute `product_type` (DeriveProductType is
+  // real backend logic this shouldn't reproduce client-side) - onSettled's
+  // invalidateQueries reconciles that within one round-trip regardless.
+  function recomputeCartTotals(previous: CartResponse, items: CartItem[]): CartResponse {
+    const subtotal = items.reduce((sum, i) => sum + i.unit_price * i.quantity, 0)
+    const item_count = items.reduce((sum, i) => sum + i.quantity, 0)
+    return { ...previous, items, subtotal, total: subtotal, item_count }
+  }
 
-    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'] })
-      },
-    })
+  // ── Update Cart Item Mutation ─────────────────────────────────────────────
+  // REAL GAP FIXED (2026-09-23), owner-requested: add-to-cart already felt
+  // instant (the caller shows its own success toast without waiting for the
+  // mutation to settle), but remove/update-quantity only updated the visible
+  // list once the server round-trip finished and the query refetched -
+  // sluggish by comparison. Both now write the predicted result straight
+  // into the query cache in onMutate (matching kasuvia-cart-management's own
+  // upsertLine merge/removal semantics), roll back to the exact pre-mutation
+  // snapshot in onError, and always reconcile with the server's real state
+  // in onSettled - the cache can never end up out of sync with the backend,
+  // even if two of these fire concurrently.
+  const updateCartItemMutation = useMutation({
+    mutationFn: async ({ itemId, quantity }: { itemId: string; quantity: number }) => {
+      if (resolvedToken) {
+        return updateCartItem(resolvedConfig, resolvedToken, itemId, quantity)
+      }
+      if (guestSessionId) {
+        return updateGuestCartItemQuantity(resolvedConfig, guestSessionId, itemId, quantity)
+      }
+      throw new Error('Cannot update cart: no access token or guest session ID provided.')
+    },
+    onMutate: async ({ itemId, quantity }) => {
+      await queryClient.cancelQueries({ queryKey: cartQueryKey })
+      const previous = queryClient.getQueryData<CartResponse>(cartQueryKey)
+      if (previous) {
+        // Matches the real backend's own "quantity<=0 removes the line"
+        // contract (UpdateItemQuantity's doc comment in cart_service.go).
+        const items = quantity > 0
+          ? previous.items.map((i) => i.id === itemId ? { ...i, quantity } : i)
+          : previous.items.filter((i) => i.id !== itemId)
+        queryClient.setQueryData<CartResponse>(cartQueryKey, recomputeCartTotals(previous, items))
+      }
+      return { previous }
+    },
+    onError: (error, _variables, context) => {
+      if (context?.previous) {
+        queryClient.setQueryData(cartQueryKey, context.previous)
+      }
+      logger.error('[useCart] Failed to update item quantity, rolled back:', error)
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: ['cart'] })
+    },
+  })
 
-    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'] })
-      },
-    })
+  // ── Remove from Cart Mutation ─────────────────────────────────────────────
+  // Same optimistic/rollback pattern as updateCartItemMutation above.
+  const removeFromCartMutation = useMutation({
+    mutationFn: async (itemId: string) => {
+      if (resolvedToken) {
+        return removeFromCart(resolvedConfig, resolvedToken, itemId)
+      }
+      if (guestSessionId) {
+        return removeFromGuestCart(resolvedConfig, guestSessionId, itemId)
+      }
+      throw new Error('Cannot remove from cart: no access token or guest session ID provided.')
+    },
+    onMutate: async (itemId) => {
+      await queryClient.cancelQueries({ queryKey: cartQueryKey })
+      const previous = queryClient.getQueryData<CartResponse>(cartQueryKey)
+      if (previous) {
+        const items = previous.items.filter((i) => i.id !== itemId)
+        queryClient.setQueryData<CartResponse>(cartQueryKey, recomputeCartTotals(previous, items))
+      }
+      return { previous }
+    },
+    onError: (error, _itemId, context) => {
+      if (context?.previous) {
+        queryClient.setQueryData(cartQueryKey, context.previous)
+      }
+      logger.error('[useCart] Failed to remove item, rolled back:', error)
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: ['cart'] })
+    },
+  })
 
-    const mergeGuestCartMutation = useMutation({
-      mutationFn: (guestSessionId: string) =>
-        resolvedToken ? mergeGuestCartIfPresent(resolvedConfig, resolvedToken, guestSessionId) : Promise.resolve(),
-      onSuccess: () => {
-        queryClient.invalidateQueries({ queryKey: ['cart'] })
-      },
-    })
+  // ── Clear Cart Mutation ───────────────────────────────────────────────────
+  const clearCartMutation = useMutation({
+    mutationFn: async () => {
+      if (resolvedToken) {
+        return clearCart(resolvedConfig, resolvedToken)
+      }
+      if (guestSessionId) {
+        return clearGuestCart(resolvedConfig, guestSessionId)
+      }
+      throw new Error('Cannot clear cart: no access token or guest session ID provided.')
+    },
+    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] || 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,
-      })
-    }
+  // ── Merge Guest Cart Mutation ─────────────────────────────────────────────
+  const mergeGuestCartMutation = useMutation({
+    mutationFn: (sessionId: string) => {
+      if (!resolvedToken) {
+        logger.warn('[useCart] mergeGuestCart called without an access token — skipping merge.')
+        return Promise.resolve()
+      }
+      return mergeGuestCartIfPresent(resolvedConfig, resolvedToken, sessionId)
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['cart'] })
+    },
+  })
+
+  // ── Convenience: add by Product object ───────────────────────────────────
+  // NOTE: product_slug, product_name, image_url, unit_price, is_bespoke are
+  // intentionally NOT forwarded to the backend — kasuvia-cart-management
+  // resolves them server-side. They're extracted from the Product here only
+  // for any local optimistic-UI the caller may implement; the backend response
+  // is the authoritative cart state.
+  const addItem = (product: Product, variantId?: string, quantity: number = 1, customMeasurements?: Record<string, string>) => {
+    return addToCartMutation.mutate({
+      product_id: product.id,
+      variant_id: variantId,
+      quantity,
+      custom_measurements: customMeasurements ? JSON.stringify(customMeasurements) : undefined,
+      // Below are accepted by the mutation signature for UI convenience but stripped before the fetch:
+      product_slug: product.slug || "",
+      product_name: product.name,
+      image_url: product.images[0] || undefined,
+    })
+  }
 
-    // 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 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 })
-    }
+  // mutateAsync (not mutate) so a caller's `await updateQty(...)`/`await
+  // removeItem(...)` actually rejects on failure - both already have callers
+  // using `await` + try/catch expecting this (CartClient.tsx/CartDrawer.tsx),
+  // but `.mutate()` returns void, so those awaits previously resolved
+  // instantly regardless of outcome and never caught a real failure. The
+  // optimistic cache update above already applies/rolls back independently
+  // of whether the caller awaits this at all.
+  const updateQty = (itemId: string, quantity: number) => {
+    return updateCartItemMutation.mutateAsync({ itemId, quantity })
+  }
 
-    const removeItem = (itemId: string) => {
-      removeFromCartMutation.mutate(itemId)
-    }
+  const removeItem = (itemId: string) => {
+    return removeFromCartMutation.mutateAsync(itemId)
+  }
 
-    const handleClearCartAndAdd = () => {
-      clearCartMutation.mutate()
-      setProductTypeMismatch(null)
-    }
+  const handleClearCartAndAdd = () => {
+    clearCartMutation.mutate()
+    setProductTypeMismatch(null)
+  }
 
-    const handleKeepCurrentCart = () => {
-      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,
-    }
-  } 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
+  return {
+    cart: cartQuery.data,
+    items,
+    count,
+    isOpen,
+    setOpen,
+    isLoading: cartQuery.isLoading,
+    error: cartQuery.error as Error | null,
+    addToCart: addToCartMutation.mutate,
+    updateCartItem: updateCartItemMutation.mutate,
+    removeFromCart: removeFromCartMutation.mutate,
+    clearCart: clearCartMutation.mutate,
+    clear: clearCartMutation.mutate,
+    mergeGuestCart: mergeGuestCartMutation.mutate,
+    addItem,
+    updateQty,
+    removeItem,
+    subtotal,
+    productTypeMismatch,
+    handleClearCartAndAdd,
+    handleKeepCurrentCart,
   }
 }