medusa-storefront-data 1.0.0 → 2.1.0

package/dist/server/locale-actions.js

@@ -1,8 +1,10 @@
 "use server";
-import { sdk } from "../config";
+import { medusaCartUpdate } from "medusa-services/cart";
 import { revalidateTag } from "next/cache";
 import { cookies as nextCookies } from "next/headers";
-import { getAuthHeaders, getCacheTag, getCartId } from "../cookies";
+import { getCartId, getCacheTag } from "../cookies";
+import { getStoreClientOptions } from "../util/store-client";
+import { revalidateCartTags } from "../util/revalidate-cart";
 const LOCALE_COOKIE_NAME = "_medusa_locale";
 /**
  * Gets the current locale from cookies
@@ -29,24 +31,17 @@ export const setLocaleCookie = async (locale) => {
     });
 };
 /**
- * Updates the locale preference via SDK and stores in cookie.
+ * Updates the locale preference and stores in cookie.
  * Also updates the cart with the new locale if one exists.
  */
 export const updateLocale = async (localeCode) => {
     await setLocaleCookie(localeCode);
-    // Update cart with the new locale if a cart exists
     const cartId = await getCartId();
     if (cartId) {
-        const headers = {
-            ...(await getAuthHeaders()),
-        };
-        await sdk.store.cart.update(cartId, { locale: localeCode }, {}, headers);
-        const cartCacheTag = await getCacheTag("carts");
-        if (cartCacheTag) {
-            revalidateTag(cartCacheTag);
-        }
+        const options = await getStoreClientOptions();
+        await medusaCartUpdate(cartId, { locale: localeCode }, options);
+        await revalidateCartTags();
     }
-    // Revalidate relevant caches to refresh content
     const productsCacheTag = await getCacheTag("products");
     if (productsCacheTag) {
         revalidateTag(productsCacheTag);

package/dist/server/locales.d.ts

@@ -1,7 +1,5 @@
-export type Locale = {
-    code: string;
-    name: string;
-};
+import { type StoreLocale } from "medusa-services/locales";
+export type Locale = StoreLocale;
 /**
  * Fetches available locales from the backend.
  * Returns null if the endpoint returns 404 (locales not configured).

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

@@ -1 +1 @@
-{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../src/server/locales.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,MAAM,GAAG;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,MAAM,EAAE,GAAG,IAAI,CAa3D,CAAA"}
+{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../src/server/locales.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoB,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAG5E,MAAM,MAAM,MAAM,GAAG,WAAW,CAAA;AAEhC;;;GAGG;AACH,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,MAAM,EAAE,GAAG,IAAI,CAI3D,CAAA"}

package/dist/server/locales.js

@@ -1,20 +1,12 @@
 "use server";
-import { sdk } from "../config";
-import { getCacheOptions } from "../cookies";
+import { medusaLocaleList } from "medusa-services/locales";
+import { getStoreClientOptions } from "../util/store-client";
 /**
  * Fetches available locales from the backend.
  * Returns null if the endpoint returns 404 (locales not configured).
  */
 export const listLocales = async () => {
-    const next = {
-        ...(await getCacheOptions("locales")),
-    };
-    return sdk.client
-        .fetch(`/store/locales`, {
-        method: "GET",
-        next,
-        cache: "force-cache",
-    })
-        .then(({ locales }) => locales)
-        .catch(() => null);
+    const options = await getStoreClientOptions();
+    const result = await medusaLocaleList(options);
+    return result?.locales ?? null;
 };

package/dist/server/orders.d.ts

@@ -1,5 +1,5 @@
 import { HttpTypes } from "@medusajs/types";
-export declare const retrieveOrder: (id: string) => Promise<any>;
+export declare const retrieveOrder: (id: string) => Promise<HttpTypes.StoreOrder>;
 export declare const listOrders: (limit?: number, offset?: number, filters?: Record<string, any>) => Promise<HttpTypes.StoreOrder[]>;
 export declare const createTransferRequest: (state: {
     success: boolean;
@@ -12,21 +12,21 @@ export declare const createTransferRequest: (state: {
 }>;
 export declare const acceptTransferRequest: (id: string, token: string) => Promise<{
     success: boolean;
-    error: any;
+    error: null;
     order: HttpTypes.StoreOrder;
 } | {
     success: boolean;
     error: any;
-    order: any;
+    order: null;
 }>;
 export declare const declineTransferRequest: (id: string, token: string) => Promise<{
     success: boolean;
-    error: any;
+    error: null;
     order: HttpTypes.StoreOrder;
 } | {
     success: boolean;
     error: any;
-    order: any;
+    order: null;
 }>;
 export declare const downloadInvoice: (orderId: string) => Promise<{
     success: boolean;
@@ -37,9 +37,6 @@ export declare const downloadInvoice: (orderId: string) => Promise<{
     error: any;
     data?: undefined;
 }>;
-/**
- * Cancel an order
- */
 export declare const cancelOrder: (orderId: string, reasonId?: string) => Promise<{
     success: boolean;
     error?: undefined;
@@ -47,9 +44,6 @@ export declare const cancelOrder: (orderId: string, reasonId?: string) => Promis
     success: boolean;
     error: any;
 }>;
-/**
- * Reorder an order (supports both logged-in and guest users)
- */
 export declare const reorderOrder: (orderId: string, skipVariantIds?: string[], forceReorder?: boolean) => Promise<{
     success: boolean;
     error: string;

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

@@ -1 +1 @@
-{"version":3,"file":"orders.d.ts","sourceRoot":"","sources":["../../src/server/orders.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAG3C,eAAO,MAAM,aAAa,GAAU,IAAI,MAAM,iBAwE7C,CAAA;AAED,eAAO,MAAM,UAAU,GACrB,QAAO,MAAW,EAClB,SAAQ,MAAU,EAClB,UAAU,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,oCA0B9B,CAAA;AAED,eAAO,MAAM,qBAAqB,GAChC,OAAO;IACL,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,KAAK,EAAE,SAAS,CAAC,UAAU,GAAG,IAAI,CAAA;CACnC,EACD,UAAU,QAAQ,KACjB,OAAO,CAAC;IACT,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,KAAK,EAAE,SAAS,CAAC,UAAU,GAAG,IAAI,CAAA;CACnC,CAoBA,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAU,IAAI,MAAM,EAAE,OAAO,MAAM;;;;;;;;EAOpE,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAU,IAAI,MAAM,EAAE,OAAO,MAAM;;;;;;;;EAOrE,CAAA;AAED,eAAO,MAAM,eAAe,GAAU,SAAS,MAAM;;;;;;;;EAuDpD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,GAAU,SAAS,MAAM,EAAE,WAAW,MAAM;;;;;;EAqGnE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,GAAU,SAAS,MAAM,EAAE,iBAAiB,MAAM,EAAE,EAAE,eAAc,OAAe;;;;;;;;;;;;;;;EAqI3G,CAAA"}
+{"version":3,"file":"orders.d.ts","sourceRoot":"","sources":["../../src/server/orders.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAmC3C,eAAO,MAAM,aAAa,GAAU,IAAI,MAAM,kCA4B7C,CAAA;AAED,eAAO,MAAM,UAAU,GACrB,QAAO,MAAW,EAClB,SAAQ,MAAU,EAClB,UAAU,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,oCAc9B,CAAA;AAED,eAAO,MAAM,qBAAqB,GAChC,OAAO;IACL,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,KAAK,EAAE,SAAS,CAAC,UAAU,GAAG,IAAI,CAAA;CACnC,EACD,UAAU,QAAQ,KACjB,OAAO,CAAC;IACT,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,KAAK,EAAE,SAAS,CAAC,UAAU,GAAG,IAAI,CAAA;CACnC,CAoBA,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAU,IAAI,MAAM,EAAE,OAAO,MAAM;;;WAOpC,SAAS,CAAC,UAAU;;;;;EAKpD,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAU,IAAI,MAAM,EAAE,OAAO,MAAM;;;WAOrC,SAAS,CAAC,UAAU;;;;;EAKpD,CAAA;AAED,eAAO,MAAM,eAAe,GAAU,SAAS,MAAM;;;;;;;;EAyBpD,CAAA;AAED,eAAO,MAAM,WAAW,GAAU,SAAS,MAAM,EAAE,WAAW,MAAM;;;;;;EA2BnE,CAAA;AAED,eAAO,MAAM,YAAY,GACvB,SAAS,MAAM,EACf,iBAAiB,MAAM,EAAE,EACzB,eAAc,OAAe;;;;;;;;;;;;;;;EAkF9B,CAAA"}

package/dist/server/orders.js

@@ -1,152 +1,128 @@
 "use server";
 import { cookies } from "next/headers";
-import { sdk } from "../config";
 import medusaError from "../util/medusa-error";
-import { getAuthHeaders, getCacheOptions, getCacheTag, setBuyNowCartId, removeBuyNowCartId } from "../cookies";
+import { getCacheTag, setBuyNowCartId, removeBuyNowCartId, } from "../cookies";
 import { listReturnReasons } from "./returns";
 import { revalidateTag } from "next/cache";
+import { extractReorderCartId, medusaGuestOrderCancel, medusaGuestOrderReorder, medusaOrderAcceptTransfer, medusaOrderCancel, medusaOrderDeclineTransfer, medusaOrderDownloadInvoice, medusaOrderList, medusaOrderReorder, medusaOrderRequestTransfer, medusaOrderRetrieve, MEDUSA_ORDER_DETAIL_FIELDS, } from "medusa-services/orders";
+import { medusaCartRemoveLineItem, medusaCartRetrieve, medusaCartSkipMerge, medusaCartUpdate, } from "medusa-services/cart";
+import { getGuestStoreClientOptions, getStoreCartClientOptions, getStoreClientOptionsWithToken, } from "../util/store-client";
+function throwOrderError(error) {
+    if (error && typeof error === "object" && "response" in error) {
+        medusaError(error);
+    }
+    throw error instanceof Error ? error : new Error(String(error));
+}
 export const retrieveOrder = async (id) => {
     const cookieStore = await cookies();
     const token = cookieStore.get("_medusa_jwt")?.value;
-    // Check for guest token if regular token is missing
     const guestToken = !token
-        ? (cookieStore.get("_medusa_guest_jwt")?.value || cookieStore.get("_medusa_guest_token")?.value)
+        ? (cookieStore.get("_medusa_guest_jwt")?.value ||
+            cookieStore.get("_medusa_guest_token")?.value)
         : null;
-    // Log token details for debugging (only first 20 chars for security)
-    const next = {
-        ...(await getCacheOptions("orders")),
-    };
-    // If guest user, use the main orders endpoint with guest token to get full details
-    if (guestToken && !token) {
-        const publishableKey = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY;
-        const requestHeaders = {
-            "Authorization": `Bearer ${guestToken}`
-        };
-        if (publishableKey)
-            requestHeaders["x-publishable-api-key"] = publishableKey;
-        const response = await sdk.client.fetch(`/store/orders/${id}`, {
-            method: "GET",
-            headers: requestHeaders,
-            query: {
-                fields: "id,display_id,customer_id,email,created_at,status,fulfillment_status,payment_status,currency_code,subtotal,shipping_total,tax_total,discount_total,metadata,total,*payment_collections.payments,*items,*items.metadata,*items.variant,*items.variant.images,*items.variant.product,*items.variant.product.thumbnail,*items.variant.product.images,*items.variant.product.variants,*items.product,*items.product.thumbnail,*items.product.images,*items.product.variants,*fulfillments,*fulfillments.items,*fulfillments.location_id,*returns,*returns.items,*cart,*shipping_address,*billing_address,*region,*shipping_methods"
-            },
-            cache: "no-store"
-        });
-        if (!response || !response.order) {
-            throw new Error("Order not found or access denied");
+    try {
+        if (guestToken && !token) {
+            const options = await getStoreClientOptionsWithToken(guestToken);
+            const { order } = await medusaOrderRetrieve(id, options, {
+                fields: MEDUSA_ORDER_DETAIL_FIELDS,
+            });
+            if (!order) {
+                throw new Error("Order not found or access denied");
+            }
+            return order;
         }
-        return response.order;
-    }
-    // Regular logged-in user flow
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
-    return sdk.client
-        .fetch(`/store/orders/${id}`, {
-        method: "GET",
-        query: {
-            fields: "id,display_id,customer_id,email,created_at,status,fulfillment_status,payment_status,currency_code,subtotal,shipping_total,tax_total,discount_total,metadata,total,*payment_collections.payments,*items,*items.metadata,*items.variant,*items.variant.images,*items.variant.product,*items.variant.product.variants,*items.product,*items.product.variants,*returns,*shipping_address,*billing_address,*region,*shipping_methods",
-        },
-        headers,
-        next,
-        cache: "no-store", // Changed from "force-cache" to "no-store" to always fetch fresh data
-    })
-        .then(({ order }) => {
+        const options = await getStoreCartClientOptions();
+        const { order } = await medusaOrderRetrieve(id, options, {
+            fields: MEDUSA_ORDER_DETAIL_FIELDS,
+        });
         return order;
-    })
-        .catch((err) => {
-        return medusaError(err);
-    });
+    }
+    catch (err) {
+        throwOrderError(err);
+    }
 };
 export const listOrders = async (limit = 10, offset = 0, filters) => {
-    const headers = {
-        ...(await getAuthHeaders()),
-    };
-    const next = {
-        ...(await getCacheOptions("orders")),
-    };
-    return sdk.client
-        .fetch(`/store/orders`, {
-        method: "GET",
-        query: {
+    try {
+        const options = await getStoreCartClientOptions();
+        const { orders } = await medusaOrderList(options, {
             limit,
             offset,
             order: "-created_at",
-            fields: "*items,+items.metadata,*items.variant,*items.variant.images,*items.product,*returns",
             ...filters,
-        },
-        headers,
-        next,
-        cache: "no-store",
-    })
-        .then(({ orders }) => orders)
-        .catch((err) => medusaError(err));
+        });
+        return orders;
+    }
+    catch (err) {
+        throwOrderError(err);
+    }
 };
 export const createTransferRequest = async (state, formData) => {
     const id = formData.get("order_id");
     if (!id) {
         return { success: false, error: "Order ID is required", order: null };
     }
-    const headers = await getAuthHeaders();
-    return await sdk.store.order
-        .requestTransfer(id, {}, {
-        fields: "id, email",
-    }, headers)
-        .then(({ order }) => ({ success: true, error: null, order }))
-        .catch((err) => ({ success: false, error: err.message, order: null }));
+    try {
+        const options = await getStoreCartClientOptions();
+        const { order } = await medusaOrderRequestTransfer(id, options, {
+            fields: "id, email",
+        });
+        return {
+            success: true,
+            error: null,
+            order: order,
+        };
+    }
+    catch (err) {
+        return { success: false, error: err.message, order: null };
+    }
 };
 export const acceptTransferRequest = async (id, token) => {
-    const headers = await getAuthHeaders();
-    return await sdk.store.order
-        .acceptTransfer(id, { token }, {}, headers)
-        .then(({ order }) => ({ success: true, error: null, order }))
-        .catch((err) => ({ success: false, error: err.message, order: null }));
+    try {
+        const options = await getStoreCartClientOptions();
+        const { order } = await medusaOrderAcceptTransfer(id, token, options);
+        return {
+            success: true,
+            error: null,
+            order: order,
+        };
+    }
+    catch (err) {
+        return { success: false, error: err.message, order: null };
+    }
 };
 export const declineTransferRequest = async (id, token) => {
-    const headers = await getAuthHeaders();
-    return await sdk.store.order
-        .declineTransfer(id, { token }, {}, headers)
-        .then(({ order }) => ({ success: true, error: null, order }))
-        .catch((err) => ({ success: false, error: err.message, order: null }));
+    try {
+        const options = await getStoreCartClientOptions();
+        const { order } = await medusaOrderDeclineTransfer(id, token, options);
+        return {
+            success: true,
+            error: null,
+            order: order,
+        };
+    }
+    catch (err) {
+        return { success: false, error: err.message, order: null };
+    }
 };
 export const downloadInvoice = async (orderId) => {
     try {
         const cookieStore = await cookies();
         const token = cookieStore.get("_medusa_jwt")?.value;
-        // Check for guest token if regular token is missing
         const guestToken = !token
-            ? (cookieStore.get("_medusa_guest_jwt")?.value || cookieStore.get("_medusa_guest_token")?.value)
+            ? (cookieStore.get("_medusa_guest_jwt")?.value ||
+                cookieStore.get("_medusa_guest_token")?.value)
             : null;
-        const headers = {
-            "x-publishable-api-key": process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY,
-        };
-        let url = `/store/invoice/download/${orderId}`;
+        let arrayBuffer;
         if (token) {
-            headers["Cookie"] = `_medusa_jwt=${token}`;
-            headers["Authorization"] = `Bearer ${token}`;
+            const options = await getStoreClientOptionsWithToken(token);
+            arrayBuffer = await medusaOrderDownloadInvoice(orderId, options, false);
         }
         else if (guestToken) {
-            // Use guest endpoint and token
-            url = `/store/guest/invoice/download/${orderId}`;
-            headers["Cookie"] = `_medusa_guest_jwt=${guestToken}`;
-            headers["Authorization"] = `Bearer ${guestToken}`;
+            const options = await getStoreClientOptionsWithToken(guestToken);
+            arrayBuffer = await medusaOrderDownloadInvoice(orderId, options, true);
         }
-        const backendUrl = process.env.NEXT_PUBLIC_MEDUSA_BACKEND_URL || "http://localhost:9000";
-        const response = await fetch(`${backendUrl}${url}`, {
-            method: "GET",
-            headers,
-            cache: "no-store",
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to download invoice: ${response.status} ${response.statusText}`);
-        }
-        const contentType = response.headers.get("content-type");
-        if (!contentType || !contentType.includes("application/pdf")) {
-            throw new Error("Server returned non-PDF content");
-        }
-        const arrayBuffer = await response.arrayBuffer();
-        if (arrayBuffer.byteLength === 0) {
-            throw new Error("Generated PDF is empty");
+        else {
+            throw new Error("Unauthorized: No valid session found");
         }
         const base64 = Buffer.from(arrayBuffer).toString("base64");
         return { success: true, data: base64 };
@@ -155,210 +131,93 @@ export const downloadInvoice = async (orderId) => {
         return { success: false, error: error.message };
     }
 };
-/**
- * Cancel an order
- */
 export const cancelOrder = async (orderId, reasonId) => {
     try {
-        const authHeaders = await getAuthHeaders();
-        const cookiesStore = await cookies();
-        const guestToken = cookiesStore.get("_medusa_guest_jwt")?.value || cookiesStore.get("_medusa_guest_token")?.value;
-        const publishableKey = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY;
-        const backendUrl = process.env.NEXT_PUBLIC_MEDUSA_BACKEND_URL || "http://localhost:9000";
-        // 1. Regular logged-in user flow ALWAYS takes priority
-        const token = cookiesStore.get("_medusa_jwt")?.value;
+        const cookieStore = await cookies();
+        const token = cookieStore.get("_medusa_jwt")?.value;
+        const guestOptions = await getGuestStoreClientOptions();
+        let finalReasonId = reasonId;
+        if (!finalReasonId) {
+            const reasons = await listReturnReasons();
+            finalReasonId = reasons.find((r) => r.value === "other")?.id || reasons[0]?.id || "other";
+        }
         if (token) {
-            let finalReasonId = reasonId;
-            if (!finalReasonId) {
-                const reasons = await listReturnReasons();
-                finalReasonId = reasons.find(r => r.value === "other")?.id || reasons[0]?.id || "other";
-            }
-            const headers = {
-                "Content-Type": "application/json",
-                "x-publishable-api-key": publishableKey,
-                "Authorization": `Bearer ${token}`
-            };
-            // Try the primary endpoint
-            let response = await fetch(`${backendUrl}/store/orders/cancel/${orderId}`, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({ reason_id: finalReasonId }),
-                cache: "no-store",
-            });
-            // If the first endpoint fails with 404 or a resolution error, try the alternative format
-            if (!response.ok) {
-                const errorData = await response.json().catch(() => ({}));
-                if (response.status === 404 || (errorData.message && errorData.message.includes("resolve"))) {
-                    const altResponse = await fetch(`${backendUrl}/store/orders/${orderId}/cancel`, {
-                        method: "POST",
-                        headers,
-                        body: JSON.stringify({ reason_id: finalReasonId }),
-                        cache: "no-store",
-                    });
-                    if (altResponse.ok)
-                        return { success: true };
-                    // If both fail, return the error from the second attempt
-                    const altError = await altResponse.json().catch(() => ({ message: "Failed to cancel order" }));
-                    return { success: false, error: altError.message || "Failed to cancel order" };
-                }
-                return { success: false, error: errorData.message || "Failed to cancel order" };
-            }
+            const options = await getStoreClientOptionsWithToken(token);
+            await medusaOrderCancel(orderId, finalReasonId, options);
             return { success: true };
         }
-        // 2. Only if NOT logged in, check for guest user token
-        if (guestToken) {
-            let finalReasonId = reasonId;
-            if (!finalReasonId) {
-                const reasons = await listReturnReasons();
-                finalReasonId = reasons.find(r => r.value === "other")?.id || reasons[0]?.id || "other";
-            }
-            // Try guest endpoint
-            const response = await fetch(`${backendUrl}/store/guest-orders/${orderId}/cancel`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "x-publishable-api-key": publishableKey,
-                    "Authorization": `Bearer ${guestToken}`
-                },
-                body: JSON.stringify({ reason_id: finalReasonId }),
-                cache: "no-store",
-            });
-            if (!response.ok) {
-                // Fallback for guest as well
-                const altResponse = await fetch(`${backendUrl}/store/guest/orders/${orderId}/cancel`, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        "x-publishable-api-key": publishableKey,
-                        "Authorization": `Bearer ${guestToken}`
-                    },
-                    body: JSON.stringify({ reason_id: finalReasonId }),
-                    cache: "no-store",
-                });
-                if (altResponse.ok)
-                    return { success: true };
-                return { success: false, error: "Failed to cancel order" };
-            }
+        if (guestOptions) {
+            await medusaGuestOrderCancel(orderId, finalReasonId, guestOptions);
             return { success: true };
         }
-        // 3. Neither token found
         return { success: false, error: "Unauthorized: No valid session found" };
     }
     catch (error) {
         return { success: false, error: error.message };
     }
 };
-/**
- * Reorder an order (supports both logged-in and guest users)
- */
 export const reorderOrder = async (orderId, skipVariantIds, forceReorder = false) => {
     try {
         const cookieStore = await cookies();
         const token = cookieStore.get("_medusa_jwt")?.value;
-        // Check for guest token if regular token is missing
-        const guestToken = !token
-            ? (cookieStore.get("_medusa_guest_jwt")?.value || cookieStore.get("_medusa_guest_token")?.value)
-            : null;
-        const publishableKey = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY;
-        const backendUrl = process.env.NEXT_PUBLIC_MEDUSA_BACKEND_URL || "http://localhost:9000";
-        const headers = {
-            "Content-Type": "application/json",
-            "x-publishable-api-key": publishableKey,
-        };
-        // Determine the correct endpoint based on user type
-        let url = `${backendUrl}/store/orders/reorder/${orderId}`;
+        const guestOptions = await getGuestStoreClientOptions();
+        let result;
         if (token) {
-            // IMPORTANT: The Order Management plugin requires an explicit Bearer token
-            // in the Authorization header to identify actor_id. Using getAuthHeaders()
-            // alone (which is cookie-based) is not enough for this custom endpoint.
-            headers["Authorization"] = `Bearer ${token}`;
+            const options = await getStoreClientOptionsWithToken(token);
+            result = await medusaOrderReorder(orderId, options, { force_reorder: forceReorder });
         }
-        else if (guestToken) {
-            // Use guest reorder endpoint
-            url = `${backendUrl}/store/guest-orders/${orderId}/reorder`;
-            headers["Authorization"] = `Bearer ${guestToken}`;
+        else if (guestOptions) {
+            result = await medusaGuestOrderReorder(orderId, guestOptions, {
+                force_reorder: forceReorder,
+            });
         }
         else {
             return { success: false, error: "Unauthorized: Please log in to reorder." };
         }
-        // Add force_reorder query param if requested
-        if (forceReorder) {
-            url += `?force_reorder=true`;
-        }
-        // Call the plugin's reorder endpoint (adds all items)
-        const response = await fetch(url, {
-            method: "POST",
-            headers,
-            cache: "no-store",
-        });
-        if (!response.ok) {
-            const errorBody = await response.json().catch(() => null);
-            // Handle 409 Conflict - Inventory Issues
-            if (response.status === 409 && errorBody?.inventory_issues) {
+        if (!result.ok) {
+            if (result.status === 409 && result.data.inventory_issues) {
                 return {
                     success: false,
                     error: "Inventory issues found",
-                    inventory_issues: errorBody.inventory_issues
+                    inventory_issues: result.data.inventory_issues,
                 };
             }
-            const errorMsg = errorBody?.message || "Failed to reorder";
-            return { success: false, error: errorMsg };
+            return { success: false, error: result.data.message || "Failed to reorder" };
         }
-        const data = await response.json();
-        // Support multiple response formats: data.cart.id, data.id, or data.cart_id
-        const newCartId = data.cart?.id || data.id || data.cart_id || (data.reorder?.cart_id);
-        // Set the cart ID in cookies and revalidate
+        const data = result.data;
+        const newCartId = extractReorderCartId(data);
+        const cartOptions = token
+            ? await getStoreClientOptionsWithToken(token)
+            : guestOptions;
         if (newCartId) {
-            // 1. Tag the cart as Buy Now to prevent merging and allow auto-restore, 
-            // and add is_reorder flag to distinguish it
             try {
-                await sdk.store.cart.update(newCartId, {
-                    metadata: {
-                        is_reorder: true
-                    }
-                }, {}, {
-                    ...headers,
-                    cache: "no-store",
-                });
-                // 2. Ensure this new cart is not merged with existing ones (CRITICAL for Buy Now flow)
-                await sdk.client.fetch(`/store/carts/merge/skip`, {
-                    method: "POST",
-                    body: { cart_id: newCartId },
-                    headers: headers,
-                });
+                await medusaCartUpdate(newCartId, { metadata: { is_reorder: true } }, cartOptions);
+                await medusaCartSkipMerge(newCartId, cartOptions);
             }
             catch (updateErr) {
                 console.error("[Reorder] Error updating cart metadata or skipping merge:", updateErr);
             }
-            // FALLBACK: If skipVariantIds were provided but the plugin added everything,
-            // we manually remove the unwanted items from the new cart.
             if (skipVariantIds && skipVariantIds.length > 0) {
                 try {
-                    // Fetch the new cart to find line item IDs
-                    const { cart } = await sdk.store.cart.retrieve(newCartId, {}, {
-                        ...headers,
-                    });
-                    if (cart && cart.items) {
-                        const itemsToRemove = cart.items.filter(item => item.variant_id && skipVariantIds.includes(item.variant_id));
-                        // Delete unwanted items one by one
-                        for (const item of itemsToRemove) {
-                            await sdk.store.cart.deleteLineItem(newCartId, item.id, {}, {
-                                ...headers,
-                            });
+                    const { cart } = await medusaCartRetrieve(newCartId, cartOptions);
+                    const items = cart.items ?? [];
+                    for (const item of items) {
+                        const variantId = item.variant_id;
+                        const lineId = item.id;
+                        if (variantId &&
+                            lineId &&
+                            skipVariantIds.includes(variantId)) {
+                            await medusaCartRemoveLineItem(newCartId, lineId, cartOptions);
                         }
                     }
                 }
                 catch (removeErr) {
                     console.error("[Reorder] Error removing skipped items:", removeErr);
-                    // We continue anyway since the cart is created
                 }
             }
-            // Use buy_now_cart_id instead of overwriting main cart
             await removeBuyNowCartId();
             await setBuyNowCartId(newCartId);
-            // Revalidate standard carts tag
             revalidateTag("carts");
-            // Also revalidate specific cache tag if available
             const cartCacheTag = await getCacheTag("carts");
             if (cartCacheTag)
                 revalidateTag(cartCacheTag);

package/dist/server/payment-details.d.ts

@@ -1,5 +1,5 @@
-export declare const listPaymentDetails: () => Promise<any>;
-export declare const createPaymentDetail: (type: "upi" | "bank" | "card", detail_json: Record<string, string>) => Promise<any>;
-export declare const makeDefaultPaymentDetail: (id: string) => Promise<any>;
-export declare const deletePaymentDetail: (id: string) => Promise<any>;
+export declare const listPaymentDetails: () => Promise<import("medusa-services/payment").StorePaymentDetail[]>;
+export declare const createPaymentDetail: (type: "upi" | "bank" | "card", detail_json: Record<string, string>) => Promise<Record<string, unknown>>;
+export declare const makeDefaultPaymentDetail: (id: string) => Promise<Record<string, unknown>>;
+export declare const deletePaymentDetail: (id: string) => Promise<void>;
 //# sourceMappingURL=payment-details.d.ts.map