medusa-storefront-data 1.0.0

package/dist/server/orders.js

@@ -0,0 +1,371 @@
+"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 { listReturnReasons } from "./returns";
+import { revalidateTag } from "next/cache";
+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)
+        : 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");
+        }
+        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 }) => {
+        return order;
+    })
+        .catch((err) => {
+        return medusaError(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: {
+            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));
+};
+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 }));
+};
+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 }));
+};
+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 }));
+};
+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)
+            : null;
+        const headers = {
+            "x-publishable-api-key": process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY,
+        };
+        let url = `/store/invoice/download/${orderId}`;
+        if (token) {
+            headers["Cookie"] = `_medusa_jwt=${token}`;
+            headers["Authorization"] = `Bearer ${token}`;
+        }
+        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 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");
+        }
+        const base64 = Buffer.from(arrayBuffer).toString("base64");
+        return { success: true, data: base64 };
+    }
+    catch (error) {
+        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;
+        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" };
+            }
+            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" };
+            }
+            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}`;
+        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}`;
+        }
+        else if (guestToken) {
+            // Use guest reorder endpoint
+            url = `${backendUrl}/store/guest-orders/${orderId}/reorder`;
+            headers["Authorization"] = `Bearer ${guestToken}`;
+        }
+        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) {
+                return {
+                    success: false,
+                    error: "Inventory issues found",
+                    inventory_issues: errorBody.inventory_issues
+                };
+            }
+            const errorMsg = errorBody?.message || "Failed to reorder";
+            return { success: false, error: errorMsg };
+        }
+        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
+        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,
+                });
+            }
+            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,
+                            });
+                        }
+                    }
+                }
+                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);
+        }
+        return { success: true, data };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+};

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

@@ -0,0 +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>;
+//# sourceMappingURL=payment-details.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"payment-details.d.ts","sourceRoot":"","sources":["../../src/server/payment-details.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,kBAAkB,oBAyB9B,CAAA;AAED,eAAO,MAAM,mBAAmB,GAC5B,MAAM,KAAK,GAAG,MAAM,GAAG,MAAM,EAC7B,aAAa,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,iBAWtC,CAAA;AAED,eAAO,MAAM,wBAAwB,GAAU,IAAI,MAAM,iBASxD,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAU,IAAI,MAAM,iBASnD,CAAA"}

package/dist/server/payment-details.js

@@ -0,0 +1,53 @@
+"use server";
+import { sdk } from "../config";
+import { getAuthHeaders, getCacheOptions } from "../cookies";
+export const listPaymentDetails = async () => {
+    const authHeaders = await getAuthHeaders();
+    // If no auth headers (guest user), don't even try to fetch
+    if (!authHeaders || Object.keys(authHeaders).length === 0) {
+        return [];
+    }
+    const headers = {
+        ...authHeaders,
+    };
+    const next = {
+        ...(await getCacheOptions("payment_details")),
+    };
+    return sdk.client
+        .fetch(`/store/payment-details`, {
+        method: "GET",
+        headers,
+        next,
+        cache: "no-store",
+    })
+        .then((res) => res.payment_details || [])
+        .catch(() => []);
+};
+export const createPaymentDetail = async (type, detail_json) => {
+    const headers = {
+        ...(await getAuthHeaders()),
+    };
+    return sdk.client.fetch(`/store/payment-details`, {
+        method: "POST",
+        headers,
+        body: { type, detail_json },
+    });
+};
+export const makeDefaultPaymentDetail = async (id) => {
+    const headers = {
+        ...(await getAuthHeaders()),
+    };
+    return sdk.client.fetch(`/store/payment-details/${id}/make-default`, {
+        method: "POST",
+        headers,
+    });
+};
+export const deletePaymentDetail = async (id) => {
+    const headers = {
+        ...(await getAuthHeaders()),
+    };
+    return sdk.client.fetch(`/store/payment-details/${id}`, {
+        method: "DELETE",
+        headers,
+    });
+};

package/dist/server/payment.d.ts

@@ -0,0 +1,2 @@
+export declare const listCartPaymentMethods: (regionId: string) => Promise<any>;
+//# sourceMappingURL=payment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"payment.d.ts","sourceRoot":"","sources":["../../src/server/payment.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,sBAAsB,GAAU,UAAU,MAAM,iBA4B5D,CAAA"}

package/dist/server/payment.js

@@ -0,0 +1,25 @@
+"use server";
+import { sdk } from "../config";
+import { getAuthHeaders, getCacheOptions } from "../cookies";
+export const listCartPaymentMethods = async (regionId) => {
+    const headers = {
+        ...(await getAuthHeaders()),
+    };
+    const next = {
+        ...(await getCacheOptions("payment_providers")),
+    };
+    return sdk.client
+        .fetch(`/store/payment-providers`, {
+        method: "GET",
+        query: { region_id: regionId },
+        headers,
+        next,
+        cache: "no-store",
+    })
+        .then(({ payment_providers }) => payment_providers.sort((a, b) => {
+        return a.id > b.id ? 1 : -1;
+    }))
+        .catch(() => {
+        return null;
+    });
+};

package/dist/server/products.d.ts

@@ -0,0 +1,58 @@
+import { HttpTypes } from "@medusajs/types";
+import { SortOptions } from "@modules/store/components/refinement-list/sort-products";
+export declare const listProducts: ({ pageParam, queryParams, countryCode, regionId, }: {
+    pageParam?: number;
+    queryParams?: HttpTypes.FindParams & HttpTypes.StoreProductListParams;
+    countryCode?: string;
+    regionId?: string;
+}) => Promise<{
+    response: {
+        products: HttpTypes.StoreProduct[];
+        count: number;
+    };
+    nextPage: number | null;
+    queryParams?: HttpTypes.FindParams & HttpTypes.StoreProductListParams;
+}>;
+/**
+ * This will fetch 100 products to the Next.js cache and sort them based on the sortBy parameter.
+ * It will then return the paginated products based on the page and limit parameters.
+ */
+export declare const listProductsWithSort: ({ page, queryParams, sortBy, countryCode, }: {
+    page?: number;
+    queryParams?: HttpTypes.FindParams & HttpTypes.StoreProductParams;
+    sortBy?: SortOptions;
+    countryCode: string;
+}) => Promise<{
+    response: {
+        products: HttpTypes.StoreProduct[];
+        count: number;
+    };
+    nextPage: number | null;
+    queryParams?: HttpTypes.FindParams & HttpTypes.StoreProductParams;
+}>;
+/**
+ * Fetch products that have a specific tag value
+ */
+export declare function getProductsByTag({ tagValue, limit, countryCode, }: {
+    tagValue: string;
+    limit?: number;
+    countryCode: string;
+}): Promise<HttpTypes.StoreProduct[]>;
+/**
+ * Fetch dynamic filter options from the backend API
+ */
+export declare const getDynamicFilters: (countryCode: string) => Promise<{
+    genders: any;
+    productTypes: any;
+    materials: any;
+    colors: {
+        value: string;
+        label: string;
+        hex: string;
+    }[];
+}>;
+/**
+ * Fetch a single product by its handle
+ */
+export declare function getProductByHandle(handle: string): Promise<HttpTypes.StoreProduct>;
+//# sourceMappingURL=products.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"products.d.ts","sourceRoot":"","sources":["../../src/server/products.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,yDAAyD,CAAA;AAKrF,eAAO,MAAM,YAAY,GAAU,oDAKhC;IACD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC,sBAAsB,CAAA;IACrE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,KAAG,OAAO,CAAC;IACV,QAAQ,EAAE;QAAE,QAAQ,EAAE,SAAS,CAAC,YAAY,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IAC/D,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,WAAW,CAAC,EAAE,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC,sBAAsB,CAAA;CACtE,CA6KA,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAU,6CAKxC;IACD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC,kBAAkB,CAAA;IACjE,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;CACpB,KAAG,OAAO,CAAC;IACV,QAAQ,EAAE;QAAE,QAAQ,EAAE,SAAS,CAAC,YAAY,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IAC/D,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,WAAW,CAAC,EAAE,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC,kBAAkB,CAAA;CAClE,CA6BA,CAAA;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,QAAQ,EACR,KAAU,EACV,WAAW,GACZ,EAAE;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;CACpB,qCAYA;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAAU,aAAa,MAAM;;;;;;;;;EA0F1D,CAAA;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,MAAM,mCAOtD"}