medusa-storefront-data 1.0.0 → 2.1.0

package/dist/server/cart.js

@@ -3,11 +3,32 @@ import { sdk } from "../config";
 import medusaError from "../util/medusa-error";
 import { revalidateTag, revalidatePath } from "next/cache";
 import { redirect } from "next/navigation";
+import { headers as nextHeaders } from "next/headers";
 import { getAuthHeaders, getCacheOptions, getCacheTag, getCartId, removeCartId, setCartId, getHoldCartId, setBuyNowCartId, removeBuyNowCartId, } from "../cookies";
 import { getRegion } from "./regions";
+function normalizeCartEmail(email) {
+    if (typeof email !== "string")
+        return undefined;
+    const normalized = email.trim().toLowerCase();
+    return normalized || undefined;
+}
+function isValidCartEmail(email) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+}
 import { getLocale } from "./locale-actions";
 import { retrieveCustomer } 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) {
+    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.
@@ -20,20 +41,16 @@ export const retrieveCart = cache(async (cartId, fields) => {
     // 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(`/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;
+                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");
@@ -44,12 +61,11 @@ export const retrieveCart = cache(async (cartId, fields) => {
             // Silent fail
         }
     }
-    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()),
     };
     const next = {
@@ -61,7 +77,7 @@ export const retrieveCart = cache(async (cartId, fields) => {
         query: {
             fields,
         },
-        headers,
+        headers: authHeaders,
         next,
         cache: "no-store",
     })
@@ -76,19 +92,20 @@ export async function getOrSetCart(countryCode) {
         throw new Error(`Region not found for country code: ${countryCode}`);
     }
     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;
         await setCartId(cart.id);
         const cartCacheTag = await getCacheTag("carts");
         revalidateTag(cartCacheTag);
     }
     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);
     }
@@ -99,19 +116,15 @@ export async function updateCart(data) {
     if (!cartId) {
         throw new Error("No existing cart found, please create one before updating");
     }
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
-    return sdk.store.cart
-        .update(cartId, data, {}, headers)
-        .then(async ({ cart }) => {
-        const cartCacheTag = await getCacheTag("carts");
-        revalidateTag(cartCacheTag);
-        const fulfillmentCacheTag = await getCacheTag("fulfillment");
-        revalidateTag(fulfillmentCacheTag);
+    try {
+        const options = await getStoreCartClientOptions();
+        const { cart } = await medusaCartUpdate(cartId, data, options);
+        await revalidateCartTags();
         return cart;
-    })
-        .catch(medusaError);
+    }
+    catch (e) {
+        throwCartError(e);
+    }
 }
 export async function addToCart({ variantId, quantity, countryCode, }) {
     if (!variantId) {
@@ -121,21 +134,14 @@ export async function addToCart({ variantId, quantity, countryCode, }) {
     if (!cart) {
         throw new Error("Error retrieving or creating cart");
     }
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
-    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);
+    try {
+        const options = await getStoreCartClientOptions();
+        await medusaCartAddLineItem(cart.id, { variant_id: variantId, quantity }, options);
+        await revalidateCartTags();
+    }
+    catch (e) {
+        throwCartError(e);
+    }
 }
 export async function buyNow({ variantId, quantity, countryCode, }) {
     if (!variantId) {
@@ -145,36 +151,26 @@ export async function buyNow({ variantId, quantity, countryCode, }) {
     if (!region) {
         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({
+    const { cart } = await medusaCartCreate(options, {
         region_id: region.id,
         locale: locale || undefined,
-        metadata: { is_buy_now: true }
-    }, {}, headers);
-    const cart = cartResp.cart;
+        metadata: { is_buy_now: true },
+    });
     // Save the new cart id in "buy_now_cart_id" cookie
     await removeBuyNowCartId();
     await setBuyNowCartId(cart.id);
     // 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)
     // 4. OPTIMIZATION: If user is logged in and has addresses, auto-fill and skip to payment
     const customer = await retrieveCustomer().catch(() => null);
@@ -183,7 +179,7 @@ export async function buyNow({ variantId, quantity, countryCode, }) {
     if (defaultAddress) {
         try {
             // Set addresses
-            await sdk.store.cart.update(cart.id, {
+            await medusaCartUpdate(cart.id, {
                 shipping_address: {
                     first_name: defaultAddress.first_name,
                     last_name: defaultAddress.last_name,
@@ -208,16 +204,12 @@ export async function buyNow({ variantId, quantity, countryCode, }) {
                     phone: defaultAddress.phone,
                     company: defaultAddress.company,
                 },
-                email: customer.email
-            }, {}, headers);
+                email: customer?.email ?? "",
+            }, options);
             // Fetch and set first shipping method
-            const { shipping_options } = await sdk.client.fetch("/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;
             }
         }
@@ -245,18 +237,14 @@ export async function updateLineItem({ lineId, quantity, }) {
     if (!cartId) {
         throw new Error("Missing cart ID when updating line item");
     }
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
-    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);
+    try {
+        const options = await getStoreCartClientOptions();
+        await medusaCartUpdateLineItem(cartId, lineId, { quantity }, options);
+        await revalidateCartTags();
+    }
+    catch (e) {
+        throwCartError(e);
+    }
 }
 export async function deleteLineItem(lineId) {
     if (!lineId) {
@@ -266,18 +254,14 @@ export async function deleteLineItem(lineId) {
     if (!cartId) {
         throw new Error("Missing cart ID when deleting line item");
     }
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
-    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);
+    try {
+        const options = await getStoreCartClientOptions();
+        await medusaCartRemoveLineItem(cartId, lineId, options);
+        await revalidateCartTags();
+    }
+    catch (e) {
+        throwCartError(e);
+    }
 }
 export async function updateLineItemVariant({ lineId, variantId, quantity, countryCode, }) {
     if (!lineId) {
@@ -296,26 +280,23 @@ export async function updateLineItemVariant({ lineId, variantId, quantity, count
     });
 }
 export async function setShippingMethod({ cartId, shippingMethodId, }) {
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
-    return sdk.store.cart
-        .addShippingMethod(cartId, { option_id: shippingMethodId }, {}, headers)
-        .then(async () => {
+    try {
+        const options = await getStoreCartClientOptions();
+        await medusaCartAddShippingMethod(cartId, shippingMethodId, options);
         const cartCacheTag = await getCacheTag("carts");
         revalidateTag(cartCacheTag);
-    })
-        .catch(medusaError);
+    }
+    catch (e) {
+        throwCartError(e);
+    }
 }
 /**
  * Sets a shipping method silently without triggering a full page revalidation.
  */
 export async function setShippingMethodSilently({ cartId, shippingMethodId, }) {
-    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) {
@@ -323,9 +304,6 @@ export async function setShippingMethodSilently({ cartId, shippingMethodId, }) {
     }
 }
 export async function initiatePaymentSession(cart, data) {
-    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)
@@ -372,12 +350,16 @@ export async function initiatePaymentSession(cart, data) {
             addressUpdates.billing_address = cleanAddress(latestCart.billing_address) || cleanAddress(latestCart.shipping_address);
         }
         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;
     // 4. PRE-FLIGHT VALIDATION: Only strictly block for Razorpay, be more lenient for COD
     const isRazorpayProvider = data.provider_id.includes("razorpay");
     const displayPhone = finalCart.shipping_address?.phone || finalCart.billing_address?.phone || phone;
@@ -401,36 +383,35 @@ export async function initiatePaymentSession(cart, data) {
             }
         }
     };
-    return sdk.store.payment
-        .initiatePaymentSession(finalCart, enhancedData, {}, headers)
-        .then(async (resp) => {
+    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 resp;
-    })
-        .catch((e) => {
+        return refreshedCart;
+    }
+    catch (e) {
         const errorMsg = e.message || e.response?.data?.message || "Unknown error";
-        throw new Error(`Razorpay Initialization Failed: ${errorMsg}`);
-    });
+        const label = isRazorpayProvider ? "Razorpay" : "Payment";
+        throw new Error(`${label} initialization failed: ${errorMsg}`);
+    }
 }
 export async function applyPromotions(codes) {
     const cartId = await getCartId();
     if (!cartId) {
         throw new Error("No existing cart found");
     }
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
-    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);
+    try {
+        const options = await getStoreCartClientOptions();
+        const { cart } = await medusaCartApplyPromotions(cartId, codes, options);
+        await revalidateCartTags();
         return cart;
-    })
-        .catch(medusaError);
+    }
+    catch (e) {
+        throwCartError(e);
+    }
 }
 export async function applyGiftCard(code) {
     //   const cartId = getCartId()
@@ -516,26 +497,24 @@ export async function setAddresses(currentState, formData) {
         };
         const data = {
             shipping_address: shippingAddress,
-            email: formData.get("email"),
+            email: normalizeCartEmail(formData.get("email")),
         };
+        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(`/store/customers/me`, {
-                    method: "GET",
-                    query: { fields: "*addresses" },
-                    headers: authHeaders,
-                    cache: "no-store",
-                });
+                const options = await getStoreCartClientOptions();
+                const { customer } = await medusaCustomerRetrieve(options, { fields: "*addresses" });
                 const addressExists = customer?.addresses?.some((a) => a.address_1 === shippingAddress.address_1 &&
                     a.postal_code === shippingAddress.postal_code &&
                     a.city === shippingAddress.city &&
                     a.first_name === shippingAddress.first_name &&
                     a.last_name === shippingAddress.last_name);
                 if (!addressExists) {
-                    await sdk.store.customer.createAddress(shippingAddress, {}, authHeaders);
+                    await medusaCustomerCreateAddress(shippingAddress, options);
                     const customerCacheTag = await getCacheTag("customers");
                     revalidateTag(customerCacheTag);
                 }
@@ -580,19 +559,19 @@ export async function placeOrder(cartId) {
     if (!id) {
         throw new Error("No existing cart found when placing an order");
     }
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
-    const cartRes = await sdk.store.cart
-        .complete(id, {}, headers)
-        .then(async (cartRes) => {
+    let cartRes;
+    try {
+        const options = await getStoreCartClientOptions();
+        cartRes = await medusaCartComplete(id, options);
         const cartCacheTag = await getCacheTag("carts");
         revalidateTag(cartCacheTag);
-        return cartRes;
-    })
-        .catch(medusaError);
+    }
+    catch (e) {
+        throwCartError(e);
+    }
     if (cartRes?.type === "order") {
-        const countryCode = cartRes.order.shipping_address?.country_code?.toLowerCase();
+        const order = cartRes.order;
+        const countryCode = order.shipping_address?.country_code?.toLowerCase();
         const orderCacheTag = await getCacheTag("orders");
         revalidateTag(orderCacheTag);
         // NEW LOGIC: Check if we just completed a Buy Now cart
@@ -608,7 +587,7 @@ export async function placeOrder(cartId) {
             // Regular checkout: clear the main cart
             await removeCartId();
         }
-        redirect(`/${countryCode}/order/${cartRes?.order.id}/confirmed`);
+        redirect(`/${countryCode}/order/${order.id}/confirmed`);
     }
     return cartRes.cart;
 }
@@ -651,9 +630,6 @@ export async function listCartOptions() {
 }
 export async function addCustomerAddressToCart(currentState, formData) {
     try {
-        const headers = {
-            ...(await getAuthHeaders()),
-        };
         const shippingCountryCode = formData.get("shipping_address.country_code")?.toLowerCase() || "in";
         // Parse address data from formData (which uses shipping_address. prefix)
         const addressData = {
@@ -676,11 +652,12 @@ export async function addCustomerAddressToCart(currentState, 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);
@@ -707,8 +684,11 @@ export async function addCustomerAddressToCart(currentState, formData) {
                 country_code: addressData.country_code,
                 phone: addressData.phone,
             },
-            email: formData.get("email"),
+            email: normalizeCartEmail(formData.get("email")),
         };
+        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;
@@ -735,15 +715,17 @@ export async function updateAddressSilently(data) {
     if (!cartId)
         return;
     try {
-        const headers = {
-            ...(await getAuthHeaders()),
-        };
-        await sdk.store.cart.update(cartId, data, {}, headers);
+        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." };
+            }
+        }
+        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) {
@@ -758,10 +740,8 @@ export async function updateCartMetadataSilently(metadata) {
     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 };
     }
@@ -770,31 +750,25 @@ export async function updateCartMetadataSilently(metadata) {
     }
 }
 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(`/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 = [];
         let reorderCarts = [];
         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;
+            const filteredCarts = carts.filter((c) => c.id !== currentCartId);
+            const meta = (c) => c.metadata;
+            buyNowCarts = filteredCarts.filter((c) => meta(c)?.is_buy_now === true);
+            reorderCarts = filteredCarts.filter((c) => meta(c)?.is_reorder === true);
         }
         return { buyNowCarts, reorderCarts };
     }
@@ -810,13 +784,9 @@ export async function resumeAbandonedCart(cartId, countryCode) {
     redirect(`/${countryCode}/checkout?cart_id=${cartId}`);
 }
 export async function deleteCart(cartId) {
-    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 };
     }

package/dist/server/categories.d.ts

@@ -1,3 +1,4 @@
-export declare const listCategories: (query?: Record<string, any>) => Promise<any[]>;
-export declare const getCategoryByHandle: (categoryHandle: string[]) => Promise<any>;
+import { HttpTypes } from "@medusajs/types";
+export declare const listCategories: (query?: Record<string, any>) => Promise<HttpTypes.StoreProductCategory[]>;
+export declare const getCategoryByHandle: (categoryHandle: string[]) => Promise<HttpTypes.StoreProductCategory | null>;
 //# sourceMappingURL=categories.d.ts.map

package/dist/server/categories.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"categories.d.ts","sourceRoot":"","sources":["../../src/server/categories.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc,GAAU,QAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,mBAsC/D,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAU,gBAAgB,MAAM,EAAE,iBAiDjE,CAAA"}
+{"version":3,"file":"categories.d.ts","sourceRoot":"","sources":["../../src/server/categories.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAI3C,eAAO,MAAM,cAAc,GAAU,QAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,8CAW/D,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAU,gBAAgB,MAAM,EAAE,mDAuBjE,CAAA"}