medusa-storefront-data 1.0.0 → 2.1.0

package/src/server/cart.ts

@@ -1,11 +1,12 @@
 "use server"
 
+import type { FetchArgs } from "@medusajs/js-sdk"
 import { sdk } from "../config"
 import medusaError from "../util/medusa-error"
 import { HttpTypes } from "@medusajs/types"
 import { revalidateTag, revalidatePath } from "next/cache"
 import { redirect } from "next/navigation"
-import { headers } from "next/headers"
+import { headers as nextHeaders } from "next/headers"
 import {
   getAuthHeaders,
   getCacheOptions,
@@ -20,11 +21,52 @@ import {
   removeBuyNowCartId,
 } from "../cookies"
 import { getRegion } from "./regions"
+
+function normalizeCartEmail(email: unknown): string | undefined {
+  if (typeof email !== "string") return undefined
+  const normalized = email.trim().toLowerCase()
+  return normalized || undefined
+}
+
+function isValidCartEmail(email: string): boolean {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)
+}
 import { getLocale } from "./locale-actions"
 import { retrieveCustomer, transferCart } from "./customer"
+import {
+  medusaCartCreate,
+  medusaCartRetrieve,
+  medusaCartUpdate,
+  medusaCartAddLineItem,
+  medusaCartUpdateLineItem,
+  medusaCartRemoveLineItem,
+  medusaCartApplyPromotions,
+  medusaCartAddShippingMethod,
+  medusaCartComplete,
+  medusaCartSkipMerge,
+  medusaCartDelete,
+  medusaCartList,
+  medusaShippingOptionsList,
+  MEDUSA_STORE_CART_DETAIL_FIELDS,
+} from "medusa-services/cart"
+import {
+  medusaCustomerCreateAddress,
+  medusaCustomerRetrieve,
+  medusaCustomerUpdateAddress,
+} from "medusa-services/customer"
+import { medusaPaymentSessionInitiate } from "medusa-services/payment"
+import { getStoreCartClientOptions } from "../util/store-client"
+import { revalidateCartTags } from "../util/revalidate-cart"
 
 import { cache } from "react"
 
+function throwCartError(error: unknown): never {
+  if (error && typeof error === "object" && "response" in error) {
+    medusaError(error)
+  }
+  throw error instanceof Error ? error : new Error(String(error))
+}
+
 /**
  * Retrieves a cart by its ID. If no ID is provided, it will use the cart ID from the cookies.
  * @param cartId - optional - The ID of the cart to retrieve.
@@ -39,22 +81,18 @@ export const retrieveCart = cache(
     // If we're not explicitly asking for a specific cartId and we have an active cart
     if (!cartId && id) {
       try {
-        const headerList = await headers()
+        const headerList = await nextHeaders()
         const pathname = headerList.get("x-pathname") || headerList.get("referer") || ""
         
         // Skip metadata check if we are clearly in checkout to avoid extra API call
         if (!pathname.includes("/checkout")) {
-          const currentCart = await sdk.client
-            .fetch<HttpTypes.StoreCartResponse>(`/store/carts/${id}`, {
-              method: "GET",
-              query: { fields: "metadata" },
-              headers: await getAuthHeaders(),
-              cache: "no-store",
-            })
+          const options = await getStoreCartClientOptions()
+          const currentCart = await medusaCartRetrieve(id, options, { fields: "metadata" })
             .then(({ cart }) => cart)
             .catch(() => null)
 
-          if (currentCart?.metadata?.is_buy_now || currentCart?.metadata?.is_reorder) {
+          const cartMeta = currentCart?.metadata as Record<string, unknown> | null | undefined
+          if (cartMeta?.is_buy_now || cartMeta?.is_reorder) {
             await removeBuyNowCartId()
             id = await getCartId() // Re-fetch ID which will now fall back to the real main cart
             revalidateTag("carts")
@@ -65,14 +103,13 @@ export const retrieveCart = cache(
       }
     }
 
-    fields ??=
-      "*items, *region, *items.product, *items.product.thumbnail, *items.product.images, *items.product.options, *items.product.variants, +items.product.variants.inventory_quantity, +items.product.variants.manage_inventory, +items.product.variants.allow_backorder, *items.product.variants.options, *items.variant, +items.variant.inventory_quantity, +items.variant.manage_inventory, +items.variant.allow_backorder, *items.variant.images, *items.variant.product, *items.variant.product.thumbnail, *items.variant.product.images, *items.variant.options, *items.thumbnail, *items.metadata, +items.total, +items.adjustments, *promotions, +shipping_methods.name, +shipping_methods.adjustments"
+    fields ??= MEDUSA_STORE_CART_DETAIL_FIELDS
 
     if (!id) {
       return null
     }
 
-    const headers = {
+    const authHeaders = {
       ...(await getAuthHeaders()),
     }
 
@@ -86,10 +123,10 @@ export const retrieveCart = cache(
         query: {
           fields,
         },
-        headers,
+        headers: authHeaders,
         next,
         cache: "no-store",
-      })
+      } as FetchArgs & { next?: typeof next; cache?: RequestCache })
       .then(({ cart }: { cart: HttpTypes.StoreCart }) => {
         return cart
       })
@@ -106,19 +143,15 @@ export async function getOrSetCart(countryCode: string) {
   }
 
   let cart = await retrieveCart(undefined, "id,region_id")
-
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
+  const options = await getStoreCartClientOptions()
 
   if (!cart) {
     const locale = await getLocale()
-    const cartResp = await sdk.store.cart.create(
-      { region_id: region.id, locale: locale || undefined },
-      {},
-      headers
-    )
-    cart = cartResp.cart
+    const { cart: createdCart } = await medusaCartCreate(options, {
+      region_id: region.id,
+      locale: locale || undefined,
+    })
+    cart = createdCart as unknown as HttpTypes.StoreCart
 
     await setCartId(cart.id)
 
@@ -127,7 +160,7 @@ export async function getOrSetCart(countryCode: string) {
   }
 
   if (cart && cart?.region_id !== region.id) {
-    await sdk.store.cart.update(cart.id, { region_id: region.id }, {}, headers)
+    await medusaCartUpdate(cart.id, { region_id: region.id }, options)
     const cartCacheTag = await getCacheTag("carts")
     revalidateTag(cartCacheTag)
   }
@@ -142,22 +175,14 @@ export async function updateCart(data: HttpTypes.StoreUpdateCart) {
     throw new Error("No existing cart found, please create one before updating")
   }
 
-  const headers = {
-    ...(await getAuthHeaders()),
+  try {
+    const options = await getStoreCartClientOptions()
+    const { cart } = await medusaCartUpdate(cartId, data as Record<string, unknown>, options)
+    await revalidateCartTags()
+    return cart as unknown as HttpTypes.StoreCart
+  } catch (e) {
+    throwCartError(e)
   }
-
-  return sdk.store.cart
-    .update(cartId, data, {}, headers)
-    .then(async ({ cart }: { cart: HttpTypes.StoreCart }) => {
-      const cartCacheTag = await getCacheTag("carts")
-      revalidateTag(cartCacheTag)
-
-      const fulfillmentCacheTag = await getCacheTag("fulfillment")
-      revalidateTag(fulfillmentCacheTag)
-
-      return cart
-    })
-    .catch(medusaError)
 }
 
 export async function addToCart({
@@ -179,28 +204,13 @@ export async function addToCart({
     throw new Error("Error retrieving or creating cart")
   }
 
-  const headers = {
-    ...(await getAuthHeaders()),
+  try {
+    const options = await getStoreCartClientOptions()
+    await medusaCartAddLineItem(cart.id, { variant_id: variantId, quantity }, options)
+    await revalidateCartTags()
+  } catch (e) {
+    throwCartError(e)
   }
-
-  await sdk.store.cart
-    .createLineItem(
-      cart.id,
-      {
-        variant_id: variantId,
-        quantity,
-      },
-      {},
-      headers
-    )
-    .then(async () => {
-      const cartCacheTag = await getCacheTag("carts")
-      revalidateTag(cartCacheTag)
-
-      const fulfillmentCacheTag = await getCacheTag("fulfillment")
-      revalidateTag(fulfillmentCacheTag)
-    })
-    .catch(medusaError)
 }
 
 export async function buyNow({
@@ -222,23 +232,15 @@ export async function buyNow({
     throw new Error(`Region not found for country code: ${countryCode}`)
   }
 
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
-
+  const options = await getStoreCartClientOptions()
   const locale = await getLocale()
   
   // 1. Create a NEW cart regardless of existing one
-  const cartResp = await sdk.store.cart.create(
-    { 
-      region_id: region.id, 
-      locale: locale || undefined,
-      metadata: { is_buy_now: true } 
-    },
-    {},
-    headers
-  )
-  const cart = cartResp.cart
+  const { cart } = await medusaCartCreate(options, {
+    region_id: region.id,
+    locale: locale || undefined,
+    metadata: { is_buy_now: true },
+  })
 
   // Save the new cart id in "buy_now_cart_id" cookie
   await removeBuyNowCartId()
@@ -246,25 +248,13 @@ export async function buyNow({
 
   // Ensure this new cart is not merged with existing ones
   try {
-    await sdk.client.fetch(`/store/carts/merge/skip`, {
-      method: "POST",
-      body: { cart_id: cart.id },
-      headers,
-    })
+    await medusaCartSkipMerge(cart.id, options)
   } catch (e) {
     console.error("Failed to skip cart merge for buy now cart:", e)
   }
 
   // 2. Add the item to this new cart
-  await sdk.store.cart.createLineItem(
-    cart.id,
-    {
-      variant_id: variantId,
-      quantity,
-    },
-    {},
-    headers
-  )
+  await medusaCartAddLineItem(cart.id, { variant_id: variantId, quantity }, options)
 
   // 3. (REMOVED: No longer overwriting the main cart ID, because getCartId handles buy_now_cart_id priority)
 
@@ -278,45 +268,43 @@ export async function buyNow({
   if (defaultAddress) {
     try {
       // Set addresses
-      await sdk.store.cart.update(cart.id, {
-        shipping_address: {
-          first_name: defaultAddress.first_name,
-          last_name: defaultAddress.last_name,
-          address_1: defaultAddress.address_1,
-          address_2: defaultAddress.address_2,
-          city: defaultAddress.city,
-          country_code: defaultAddress.country_code,
-          postal_code: defaultAddress.postal_code,
-          province: defaultAddress.province,
-          phone: defaultAddress.phone,
-          company: defaultAddress.company,
-        },
-        billing_address: {
-          first_name: defaultAddress.first_name,
-          last_name: defaultAddress.last_name,
-          address_1: defaultAddress.address_1,
-          address_2: defaultAddress.address_2,
-          city: defaultAddress.city,
-          country_code: defaultAddress.country_code,
-          postal_code: defaultAddress.postal_code,
-          province: defaultAddress.province,
-          phone: defaultAddress.phone,
-          company: defaultAddress.company,
+      await medusaCartUpdate(
+        cart.id,
+        {
+          shipping_address: {
+            first_name: defaultAddress.first_name,
+            last_name: defaultAddress.last_name,
+            address_1: defaultAddress.address_1,
+            address_2: defaultAddress.address_2,
+            city: defaultAddress.city,
+            country_code: defaultAddress.country_code,
+            postal_code: defaultAddress.postal_code,
+            province: defaultAddress.province,
+            phone: defaultAddress.phone,
+            company: defaultAddress.company,
+          },
+          billing_address: {
+            first_name: defaultAddress.first_name,
+            last_name: defaultAddress.last_name,
+            address_1: defaultAddress.address_1,
+            address_2: defaultAddress.address_2,
+            city: defaultAddress.city,
+            country_code: defaultAddress.country_code,
+            postal_code: defaultAddress.postal_code,
+            province: defaultAddress.province,
+            phone: defaultAddress.phone,
+            company: defaultAddress.company,
+          },
+          email: customer?.email ?? "",
         },
-        email: customer.email
-      }, {}, headers)
+        options
+      )
 
       // Fetch and set first shipping method
-      const { shipping_options } = await sdk.client.fetch<{
-        shipping_options: HttpTypes.StoreCartShippingOption[]
-      }>("/store/shipping-options", {
-        query: { cart_id: cart.id },
-        headers,
-        cache: "no-store",
-      })
+      const { shipping_options } = await medusaShippingOptionsList(cart.id, options)
 
       if (shipping_options?.length > 0) {
-        await sdk.store.cart.addShippingMethod(cart.id, { option_id: shipping_options[0].id }, {}, headers)
+        await medusaCartAddShippingMethod(cart.id, shipping_options[0].id, options)
         skipToPayment = true
       }
     } catch (e) {
@@ -354,20 +342,13 @@ export async function updateLineItem({
     throw new Error("Missing cart ID when updating line item")
   }
 
-  const headers = {
-    ...(await getAuthHeaders()),
+  try {
+    const options = await getStoreCartClientOptions()
+    await medusaCartUpdateLineItem(cartId, lineId, { quantity }, options)
+    await revalidateCartTags()
+  } catch (e) {
+    throwCartError(e)
   }
-
-  await sdk.store.cart
-    .updateLineItem(cartId, lineId, { quantity }, {}, headers)
-    .then(async () => {
-      const cartCacheTag = await getCacheTag("carts")
-      revalidateTag(cartCacheTag)
-
-      const fulfillmentCacheTag = await getCacheTag("fulfillment")
-      revalidateTag(fulfillmentCacheTag)
-    })
-    .catch(medusaError)
 }
 
 export async function deleteLineItem(lineId: string) {
@@ -381,20 +362,13 @@ export async function deleteLineItem(lineId: string) {
     throw new Error("Missing cart ID when deleting line item")
   }
 
-  const headers = {
-    ...(await getAuthHeaders()),
+  try {
+    const options = await getStoreCartClientOptions()
+    await medusaCartRemoveLineItem(cartId, lineId, options)
+    await revalidateCartTags()
+  } catch (e) {
+    throwCartError(e)
   }
-
-  await sdk.store.cart
-    .deleteLineItem(cartId, lineId, {}, headers)
-    .then(async () => {
-      const cartCacheTag = await getCacheTag("carts")
-      revalidateTag(cartCacheTag)
-
-      const fulfillmentCacheTag = await getCacheTag("fulfillment")
-      revalidateTag(fulfillmentCacheTag)
-    })
-    .catch(medusaError)
 }
 
 export async function updateLineItemVariant({
@@ -434,17 +408,14 @@ export async function setShippingMethod({
   cartId: string
   shippingMethodId: string
 }) {
-  const headers = {
-    ...(await getAuthHeaders()),
+  try {
+    const options = await getStoreCartClientOptions()
+    await medusaCartAddShippingMethod(cartId, shippingMethodId, options)
+    const cartCacheTag = await getCacheTag("carts")
+    revalidateTag(cartCacheTag)
+  } catch (e) {
+    throwCartError(e)
   }
-
-  return sdk.store.cart
-    .addShippingMethod(cartId, { option_id: shippingMethodId }, {}, headers)
-    .then(async () => {
-      const cartCacheTag = await getCacheTag("carts")
-      revalidateTag(cartCacheTag)
-    })
-    .catch(medusaError)
 }
 
 /**
@@ -457,12 +428,9 @@ export async function setShippingMethodSilently({
   cartId: string
   shippingMethodId: string
 }) {
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
-
   try {
-    await sdk.store.cart.addShippingMethod(cartId, { option_id: shippingMethodId }, {}, headers)
+    const options = await getStoreCartClientOptions()
+    await medusaCartAddShippingMethod(cartId, shippingMethodId, options)
     return { success: true }
   } catch (e) {
     return { success: false }
@@ -474,10 +442,6 @@ export async function initiatePaymentSession(
   cart: HttpTypes.StoreCart,
   data: HttpTypes.StoreInitializePaymentSession
 ) {
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
-
   // 1. RE-FETCH cart with NO CACHE to ensure we have the latest data from the DB
   const latestCart = await retrieveCart(cart.id)
   if (!latestCart) throw new Error("Cart not found")
@@ -526,13 +490,17 @@ export async function initiatePaymentSession(
     }
 
     if (Object.keys(addressUpdates).length > 0) {
-      await sdk.store.cart.update(latestCart.id, addressUpdates, {}, headers)
+      const options = await getStoreCartClientOptions()
+      await medusaCartUpdate(latestCart.id, addressUpdates, options)
     }
   }
 
-  // 3. Final re-fetch (direct SDK call to bypass any lib-level cache)
-  const cartResponse = await sdk.store.cart.retrieve(cart.id, { fields: "*shipping_address,*billing_address" }, headers)
-  const finalCart = cartResponse.cart
+  // 3. Final re-fetch (direct call to bypass any lib-level cache)
+  const options = await getStoreCartClientOptions()
+  const { cart: finalCartRaw } = await medusaCartRetrieve(cart.id, options, {
+    fields: "*shipping_address,*billing_address",
+  })
+  const finalCart = finalCartRaw as unknown as HttpTypes.StoreCart
 
   // 4. PRE-FLIGHT VALIDATION: Only strictly block for Razorpay, be more lenient for COD
   const isRazorpayProvider = data.provider_id.includes("razorpay")
@@ -561,17 +529,19 @@ export async function initiatePaymentSession(
     }
   }
 
-  return sdk.store.payment
-    .initiatePaymentSession(finalCart, enhancedData, {}, headers)
-    .then(async (resp) => {
-      const cartCacheTag = await getCacheTag("carts")
-      revalidateTag(cartCacheTag)
-      return resp
-    })
-    .catch((e) => {
-      const errorMsg = e.message || e.response?.data?.message || "Unknown error"
-      throw new Error(`Razorpay Initialization Failed: ${errorMsg}`)
+  try {
+    await medusaPaymentSessionInitiate(finalCart.id, enhancedData, options)
+    const { cart: refreshedCart } = await medusaCartRetrieve(finalCart.id, options, {
+      fields: `${MEDUSA_STORE_CART_DETAIL_FIELDS}, *payment_collection, *payment_collection.payment_sessions`,
     })
+    const cartCacheTag = await getCacheTag("carts")
+    revalidateTag(cartCacheTag)
+    return refreshedCart as unknown as HttpTypes.StoreCart
+  } catch (e: any) {
+    const errorMsg = e.message || e.response?.data?.message || "Unknown error"
+    const label = isRazorpayProvider ? "Razorpay" : "Payment"
+    throw new Error(`${label} initialization failed: ${errorMsg}`)
+  }
 }
 
 export async function applyPromotions(codes: string[]) {
@@ -581,22 +551,14 @@ export async function applyPromotions(codes: string[]) {
     throw new Error("No existing cart found")
   }
 
-  const headers = {
-    ...(await getAuthHeaders()),
+  try {
+    const options = await getStoreCartClientOptions()
+    const { cart } = await medusaCartApplyPromotions(cartId, codes, options)
+    await revalidateCartTags()
+    return cart as unknown as HttpTypes.StoreCart
+  } catch (e) {
+    throwCartError(e)
   }
-
-  return sdk.store.cart
-    .update(cartId, { promo_codes: codes }, {}, headers)
-    .then(async ({ cart }) => {
-      const cartCacheTag = await getCacheTag("carts")
-      revalidateTag(cartCacheTag)
-
-      const fulfillmentCacheTag = await getCacheTag("fulfillment")
-      revalidateTag(fulfillmentCacheTag)
-      
-      return cart
-    })
-    .catch(medusaError)
 }
 
 export async function applyGiftCard(code: string) {
@@ -693,22 +655,21 @@ export async function setAddresses(currentState: unknown, formData: FormData) {
 
     const data = {
       shipping_address: shippingAddress,
-      email: formData.get("email"),
+      email: normalizeCartEmail(formData.get("email")),
     } as any
 
+    if (data.email && !isValidCartEmail(data.email)) {
+      throw new Error("Please enter a valid email address.")
+    }
+
 
 
     // Save address to customer profile if logged in
     const authHeaders = await getAuthHeaders()
     if (authHeaders && "authorization" in authHeaders) {
       try {
-        // Fetch current customer to check if address already exists
-        const { customer } = await sdk.client.fetch<{ customer: HttpTypes.StoreCustomer }>(`/store/customers/me`, {
-          method: "GET",
-          query: { fields: "*addresses" },
-          headers: authHeaders as Record<string, string>,
-          cache: "no-store",
-        })
+        const options = await getStoreCartClientOptions()
+        const { customer } = await medusaCustomerRetrieve(options, { fields: "*addresses" })
 
         const addressExists = customer?.addresses?.some((a: any) =>
           a.address_1 === shippingAddress.address_1 &&
@@ -719,7 +680,7 @@ export async function setAddresses(currentState: unknown, formData: FormData) {
         )
 
         if (!addressExists) {
-          await sdk.store.customer.createAddress(shippingAddress, {}, authHeaders as Record<string, string>)
+          await medusaCustomerCreateAddress(shippingAddress, options)
           const customerCacheTag = await getCacheTag("customers")
           revalidateTag(customerCacheTag)
         }
@@ -768,22 +729,19 @@ export async function placeOrder(cartId?: string) {
     throw new Error("No existing cart found when placing an order")
   }
 
-  const headers = {
-    ...(await getAuthHeaders()),
+  let cartRes
+  try {
+    const options = await getStoreCartClientOptions()
+    cartRes = await medusaCartComplete(id, options)
+    const cartCacheTag = await getCacheTag("carts")
+    revalidateTag(cartCacheTag)
+  } catch (e) {
+    throwCartError(e)
   }
 
-  const cartRes = await sdk.store.cart
-    .complete(id, {}, headers)
-    .then(async (cartRes) => {
-      const cartCacheTag = await getCacheTag("carts")
-      revalidateTag(cartCacheTag)
-      return cartRes
-    })
-    .catch(medusaError)
-
   if (cartRes?.type === "order") {
-    const countryCode =
-      cartRes.order.shipping_address?.country_code?.toLowerCase()
+    const order = cartRes.order as HttpTypes.StoreOrder
+    const countryCode = order.shipping_address?.country_code?.toLowerCase()
 
     const orderCacheTag = await getCacheTag("orders")
     revalidateTag(orderCacheTag)
@@ -802,10 +760,10 @@ export async function placeOrder(cartId?: string) {
       await removeCartId()
     }
     
-    redirect(`/${countryCode}/order/${cartRes?.order.id}/confirmed`)
+    redirect(`/${countryCode}/order/${order.id}/confirmed`)
   }
 
-  return cartRes.cart
+  return cartRes.cart as unknown as HttpTypes.StoreCart
 }
 
 /**
@@ -852,15 +810,11 @@ export async function listCartOptions() {
     next,
     headers,
     cache: "force-cache",
-  })
+  } as FetchArgs & { next?: typeof next; cache?: RequestCache })
 }
 
 export async function addCustomerAddressToCart(currentState: unknown, formData: FormData) {
   try {
-    const headers = {
-      ...(await getAuthHeaders()),
-    }
-
     const shippingCountryCode = (formData.get("shipping_address.country_code") as string)?.toLowerCase() || "in"
 
     // Parse address data from formData (which uses shipping_address. prefix)
@@ -886,10 +840,11 @@ export async function addCustomerAddressToCart(currentState: unknown, formData:
     // 1. Add/Update Customer Address Book
     // We try/catch this separately so if it fails (e.g. user not logged in), we still try to proceed with checkout
     try {
+      const options = await getStoreCartClientOptions()
       if (addressId) {
-        await sdk.store.customer.updateAddress(addressId, addressData, {}, headers)
+        await medusaCustomerUpdateAddress(addressId, addressData, options)
       } else {
-        await sdk.store.customer.createAddress(addressData, {}, headers)
+        await medusaCustomerCreateAddress(addressData, options)
       }
       const customerCacheTag = await getCacheTag("customers")
       revalidateTag(customerCacheTag)
@@ -918,9 +873,13 @@ export async function addCustomerAddressToCart(currentState: unknown, formData:
         country_code: addressData.country_code,
         phone: addressData.phone,
       },
-      email: formData.get("email"),
+      email: normalizeCartEmail(formData.get("email")),
     } as any
 
+    if (cartData.email && !isValidCartEmail(cartData.email)) {
+      throw new Error("Please enter a valid email address.")
+    }
+
     const sameAsBilling = formData.get("same_as_billing")
     if (sameAsBilling === "on") {
       cartData.billing_address = cartData.shipping_address
@@ -949,18 +908,19 @@ export async function updateAddressSilently(data: any) {
   if (!cartId) return
 
   try {
-    const headers = {
-      ...(await getAuthHeaders()),
+    const payload = { ...data }
+    if (payload.email !== undefined) {
+      payload.email = normalizeCartEmail(payload.email)
+      if (payload.email && !isValidCartEmail(payload.email)) {
+        return { success: false, error: "Invalid email address." }
+      }
     }
 
-    await sdk.store.cart.update(cartId, data, {}, headers)
+    const options = await getStoreCartClientOptions()
+    await medusaCartUpdate(cartId, payload, options)
     
     // Revalidate tags to ensure CartTotals gets new shipping info
-    const cartCacheTag = await getCacheTag("carts")
-    revalidateTag(cartCacheTag)
-    
-    const fulfillmentCacheTag = await getCacheTag("fulfillment")
-    revalidateTag(fulfillmentCacheTag)
+    await revalidateCartTags()
     
     return { success: true }
   } catch (e) {
@@ -975,11 +935,8 @@ export async function updateCartMetadataSilently(metadata: any) {
   if (!cartId) return
 
   try {
-    const headers = {
-      ...(await getAuthHeaders()),
-    }
-
-    await sdk.store.cart.update(cartId, { metadata }, {}, headers)
+    const options = await getStoreCartClientOptions()
+    await medusaCartUpdate(cartId, { metadata }, options)
     // We intentionally DO NOT call revalidateTag here to prevent page refresh loops
     return { success: true }
   } catch (e) {
@@ -988,36 +945,31 @@ export async function updateCartMetadataSilently(metadata: any) {
 }
 
 export async function getAbandonedCarts() {
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
+  const authHeaders = await getAuthHeaders()
 
   // If no authorization, return empty arrays
-  if (!headers["authorization"]) {
+  if (!("authorization" in authHeaders)) {
     return { buyNowCarts: [], reorderCarts: [] }
   }
 
   try {
-    // Just fetch all carts for the customer and filter locally
-    const res = await sdk.client.fetch<{ carts: HttpTypes.StoreCart[] }>(`/store/carts`, {
-      method: "GET",
-      query: {
-        fields: "*items, *items.product, *items.product.thumbnail, *items.variant, *items.metadata, +total",
-      },
-      headers,
-      cache: "no-store",
+    const options = await getStoreCartClientOptions()
+    const res = await medusaCartList(options, {
+      fields: "*items, *items.product, *items.product.thumbnail, *items.variant, *items.metadata, +total",
     }).catch(() => null)
 
     let buyNowCarts: HttpTypes.StoreCart[] = []
     let reorderCarts: HttpTypes.StoreCart[] = []
 
     if (res && res.carts) {
-      // Filter out the main active cart
       const currentCartId = await getCartId()
-      const filteredCarts = res.carts.filter(c => c.id !== currentCartId)
-      
-      buyNowCarts = filteredCarts.filter(c => c.metadata?.is_buy_now === true)
-      reorderCarts = filteredCarts.filter(c => c.metadata?.is_reorder === true)
+      const carts = res.carts as unknown as HttpTypes.StoreCart[]
+      const filteredCarts = carts.filter((c) => c.id !== currentCartId)
+      const meta = (c: HttpTypes.StoreCart) =>
+        c.metadata as Record<string, unknown> | null | undefined
+
+      buyNowCarts = filteredCarts.filter((c) => meta(c)?.is_buy_now === true)
+      reorderCarts = filteredCarts.filter((c) => meta(c)?.is_reorder === true)
     }
 
     return { buyNowCarts, reorderCarts }
@@ -1036,14 +988,9 @@ export async function resumeAbandonedCart(cartId: string, countryCode: string) {
 }
 
 export async function deleteCart(cartId: string) {
-  const headers = await getAuthHeaders()
-
   try {
-    await sdk.client.fetch(`/store/carts/${cartId}`, {
-      method: "DELETE",
-      headers,
-      cache: "no-store",
-    })
+    const options = await getStoreCartClientOptions()
+    await medusaCartDelete(cartId, options)
     
     revalidateTag("carts")
     return { success: true }