medusa-storefront-data 1.0.0

package/src/server/returns.ts

@@ -0,0 +1,294 @@
+"use server"
+
+import { sdk } from "../config"
+import { HttpTypes } from "@medusajs/types"
+import { cookies } from "next/headers"
+import { getAuthHeaders, getCacheOptions } from "../cookies"
+import { revalidateTag } from "next/cache"
+
+export const listReturnReasons = async () => {
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  const next = {
+    ...(await getCacheOptions("return_reasons")),
+  }
+
+  return sdk.client
+    .fetch<HttpTypes.StoreReturnReasonListResponse>(`/store/return-reasons`, {
+      method: "GET",
+      headers,
+      next,
+      cache: "force-cache", // Reasons change rarely
+    })
+    .then(({ return_reasons }) => return_reasons)
+    .catch(() => [])
+}
+
+export const listReturnShippingOptions = async (
+  cartId: string,
+  regionId?: string,
+  productIds?: string[]
+): Promise<HttpTypes.StoreShippingOption[]> => {
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  const next = {
+    ...(await getCacheOptions("fulfillment")),
+  }
+
+  // Strategy 1: Try with cart_id (preferred as it has context)
+  if (cartId) {
+    try {
+      const { shipping_options } = await sdk.client.fetch<HttpTypes.StoreShippingOptionListResponse>(
+        `/store/shipping-options`,
+        {
+          method: "GET",
+          query: {
+            cart_id: cartId,
+            is_return: true,
+          },
+          headers,
+          next,
+          cache: "no-store",
+        }
+      )
+
+      if (shipping_options.length > 0) {
+        return shipping_options as unknown as HttpTypes.StoreShippingOption[]
+      }
+    } catch (e) {
+      // Fallback strategy
+    }
+  }
+
+  // Strategy 2: Fallback - Create ephemeral cart if region_id is available
+  // This is required because /store/shipping-options STRICTLY requires a cart_id for return options
+  if (regionId) {
+    try {
+      // Create a temporary cart for this region to get valid shipping options
+      const { cart } = await sdk.store.cart.create(
+        { region_id: regionId },
+        {},
+        headers
+      )
+
+      if (cart?.id) {
+        const { shipping_options } = await sdk.client.fetch<HttpTypes.StoreShippingOptionListResponse>(
+          `/store/shipping-options`,
+          {
+            method: "GET",
+            query: {
+              cart_id: cart.id,
+              is_return: true,
+            },
+            headers,
+            next,
+            cache: "no-store",
+          }
+        )
+        return shipping_options as unknown as HttpTypes.StoreShippingOption[]
+      }
+    } catch (e) {
+      // Silence error
+    }
+  }
+
+  return []
+}
+
+export const createReturnRequest = async (
+  state: {
+    success: boolean
+    error: string | null
+    return: HttpTypes.StoreReturn | null
+  },
+  formData: FormData
+): Promise<{
+  success: boolean
+  error: string | null
+  return: HttpTypes.StoreReturn | null
+}> => {
+  const orderId = formData.get("order_id") as string
+  const returnShippingOptionId = formData.get("return_shipping_option_id") as string
+  const itemsJson = formData.get("items") as string
+  const note = formData.get("note") as string
+  const locationId = formData.get("location_id") as string
+
+  if (!orderId) return { success: false, error: "Order ID is required", return: null }
+  if (!itemsJson) return { success: false, error: "Items are required", return: null }
+
+  let items: any[] = []
+  try {
+    items = JSON.parse(itemsJson)
+  } catch (e) {
+    return { success: false, error: "Invalid items data", return: null }
+  }
+
+  if (items.length === 0) {
+    return { success: false, error: "At least one item must be selected", return: null }
+  }
+
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  try {
+    // Standard Medusa v2 payload
+    const payload: any = {
+      order_id: orderId,
+      items: items.map((item) => ({
+        id: item.id,
+        quantity: item.quantity,
+        reason_id: item.return_reason_id || undefined,
+        note: (note && note.trim().length > 0) ? note : undefined,
+      })),
+      ...(returnShippingOptionId ? {
+        return_shipping: {
+          option_id: returnShippingOptionId,
+          location_id: locationId || (items[0] as any).location_id || "default_location"
+        }
+      } : {}),
+      // Optional: keep global note if supported
+      note: (note && note.trim().length > 0) ? note : "Return request",
+    }
+
+    // Double check location_id is NOT nested incorrectly if already set above
+    // The plugin expects return_shipping.location_id
+
+    // Check for any available guest tokens
+    const cookieStore = await cookies()
+    const guestToken = cookieStore.get("_medusa_guest_jwt")?.value
+      || cookieStore.get("_medusa_guest_token")?.value
+      || cookieStore.get("guest_id")?.value
+
+    const token = cookieStore.get("_medusa_jwt")?.value
+
+    let returnData: HttpTypes.StoreReturn
+
+    // If we have a guest token, try the guest specific endpoint
+    if (guestToken && !token) {
+      try {
+        const response = await sdk.client.fetch<any>(
+          `/store/guest-orders/${orderId}/returns`,
+          {
+            method: "POST",
+            body: payload,
+            headers: {
+              ...headers,
+              "Authorization": `Bearer ${guestToken}`
+            },
+            cache: "no-store",
+          }
+        )
+        returnData = response.return || response
+      } catch (e) {
+        // Fallback to standard if guest endpoint fails
+        const response = await sdk.client.fetch<{ return: HttpTypes.StoreReturn }>(
+          `/store/returns`,
+          {
+            method: "POST",
+            body: payload,
+            headers,
+            cache: "no-store",
+          }
+        )
+        returnData = response.return
+      }
+    } else {
+      // Standard flow
+      const response = await sdk.client.fetch<{ return: HttpTypes.StoreReturn }>(
+        `/store/returns`,
+        {
+          method: "POST",
+          body: payload,
+          headers,
+          cache: "no-store",
+        }
+      )
+      returnData = response.return
+    }
+
+    revalidateTag("orders")
+
+    return { success: true, error: null, return: returnData }
+  } catch (error: any) {
+    return { success: false, error: error.message || "Failed to create return request", return: null }
+  }
+}
+
+/**
+ * Link a payment method to a return (for Refund Destination)
+ */
+export const updateReturnPayment = async (returnId: string, paymentId: string) => {
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  try {
+    const response = await sdk.client.fetch<any>(
+      `/store/refund-payment-mapping/${returnId}`,
+      {
+        method: "PUT",
+        body: { payment_id: paymentId },
+        headers,
+        cache: "no-store",
+      }
+    )
+    return { success: true, data: response }
+  } catch (error: any) {
+    console.error("Update return payment fail:", error)
+    return { success: false, error: error.message }
+  }
+}
+
+/**
+ * List returns for an order or customer
+ */
+export const listReturns = async (orderId?: string) => {
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  // Authenticated flow
+  const authHeaders = headers as any
+  if (authHeaders.authorization || authHeaders.Authorization) {
+    try {
+      const response = await sdk.client.fetch<any>(`/store/returns`, {
+        method: "GET",
+        query: orderId ? { order_id: orderId } : {},
+        headers,
+        cache: "no-store",
+      })
+      return response
+    } catch (e) {
+      return { returns: [], count: 0 }
+    }
+  }
+
+  // Guest flow
+  if (orderId) {
+    const cookieStore = await cookies()
+    const guestToken = cookieStore.get("_medusa_guest_jwt")?.value || cookieStore.get("_medusa_guest_token")?.value
+
+    if (guestToken) {
+      try {
+        const response = await sdk.client.fetch<any>(`/store/guest-orders/${orderId}/returns`, {
+          method: "GET",
+          headers: {
+            ...headers,
+            "Authorization": `Bearer ${guestToken}`
+          },
+          cache: "no-store",
+        })
+        return response
+      } catch (e) {
+        return { returns: [], count: 0 }
+      }
+    }
+  }
+
+  return { returns: [], count: 0 }
+}

package/src/server/swaps.ts

@@ -0,0 +1,150 @@
+
+"use server"
+
+import { sdk } from "../config"
+import { HttpTypes } from "@medusajs/types"
+import { cookies } from "next/headers"
+import { getAuthHeaders } from "../cookies"
+import { revalidateTag } from "next/cache"
+
+/**
+ * Create an exchange (swap) request.
+ * Supports both authenticated customers and guest users.
+ */
+export const createSwapRequest = async (
+    prevState: any,
+    formData: FormData
+): Promise<{
+    success: boolean
+    error: string | null
+    swap: any | null
+}> => {
+    const orderId = formData.get("order_id") as string
+    const returnItemsJson = formData.get("return_items") as string
+    const newItemsJson = formData.get("new_items") as string
+    const reason = formData.get("reason") as string
+    const note = formData.get("note") as string
+
+    if (!orderId) return { success: false, error: "Order ID is required", swap: null }
+    if (!returnItemsJson) return { success: false, error: "Items to return are required", swap: null }
+    if (!newItemsJson) return { success: false, error: "New items are required", swap: null }
+
+    let returnItems: any[] = []
+    let newItems: any[] = []
+    try {
+        returnItems = JSON.parse(returnItemsJson)
+        newItems = JSON.parse(newItemsJson)
+    } catch (e) {
+        return { success: false, error: "Invalid items data format", swap: null }
+    }
+
+    if (returnItems.length === 0) {
+        return { success: false, error: "At least one item must be selected for return", swap: null }
+    }
+
+    const headers = {
+        ...(await getAuthHeaders()),
+    }
+
+    try {
+        const payload = {
+            order_id: orderId,
+            return_items: returnItems,
+            new_items: newItems,
+            reason: reason || "Size exchange",
+            note: note || "Exchange requested from storefront",
+        }
+
+        const cookieStore = await cookies()
+        const guestToken = cookieStore.get("_medusa_guest_jwt")?.value || cookieStore.get("_medusa_guest_token")?.value
+        const token = cookieStore.get("_medusa_jwt")?.value
+
+        let swapData: any
+
+        // Check if we should use the guest endpoint
+        if (guestToken && !token) {
+
+            const response = await sdk.client.fetch<any>(
+                `/store/guest-orders/${orderId}/swaps`,
+                {
+                    method: "POST",
+                    body: {
+                        return_items: payload.return_items,
+                        new_items: payload.new_items,
+                        reason: payload.reason,
+                        note: payload.note,
+                    },
+                    headers: {
+                        ...headers,
+                        "Authorization": `Bearer ${guestToken}`
+                    },
+                    cache: "no-store",
+                }
+            )
+            swapData = response.swap || response
+        } else {
+
+            const response = await sdk.client.fetch<any>(
+                `/store/swaps`,
+                {
+                    method: "POST",
+                    body: payload,
+                    headers,
+                    cache: "no-store",
+                }
+            )
+            swapData = response.swap || response
+        }
+
+        revalidateTag("orders")
+
+        return { success: true, error: null, swap: swapData }
+    } catch (error: any) {
+        // Extract error message from response if possible
+        let errorMsg = "Failed to create exchange request"
+        if (error.response?.data?.message) {
+            errorMsg = error.response.data.message
+        } else if (error.message) {
+            errorMsg = error.message
+        }
+
+        return { success: false, error: errorMsg, swap: null }
+    }
+}
+
+/**
+ * List swaps for an order or customer
+ */
+export const listSwaps = async (orderId?: string) => {
+    const headers = {
+        ...(await getAuthHeaders()),
+    }
+
+    // Authenticated flow
+    if ((headers as any).authorization) {
+        return sdk.client.fetch<any>(`/store/swaps`, {
+            method: "GET",
+            query: orderId ? { order_id: orderId } : {},
+            headers,
+            cache: "no-store",
+        })
+    }
+
+    // Guest flow
+    if (orderId) {
+        const cookieStore = await cookies()
+        const guestToken = cookieStore.get("_medusa_guest_jwt")?.value || cookieStore.get("_medusa_guest_token")?.value
+        if (guestToken) {
+            return sdk.client.fetch<any>(`/store/guest-orders/${orderId}/swaps`, {
+                method: "GET",
+                headers: {
+                    ...headers,
+                    "Authorization": `Bearer ${guestToken}`
+                },
+                cache: "no-store",
+            })
+        }
+    }
+
+    return { swaps: [], count: 0 }
+}

package/src/server/variants.ts

@@ -0,0 +1,38 @@
+"use server"
+
+import { sdk } from "../config"
+import { HttpTypes } from "@medusajs/types"
+
+import { getAuthHeaders, getCacheOptions } from "../cookies"
+
+export const retrieveVariant = async (
+  variant_id: string
+): Promise<HttpTypes.StoreProductVariant | null> => {
+  const authHeaders = await getAuthHeaders()
+
+  if (!authHeaders) return null
+
+  const headers = {
+    ...authHeaders,
+  }
+
+  const next = {
+    ...(await getCacheOptions("variants")),
+  }
+
+  return await sdk.client
+    .fetch<{ variant: HttpTypes.StoreProductVariant }>(
+      `/store/product-variants/${variant_id}`,
+      {
+        method: "GET",
+        query: {
+          fields: "*images",
+        },
+        headers,
+        next,
+        cache: "force-cache",
+      }
+    )
+    .then(({ variant }) => variant)
+    .catch(() => null)
+}

package/src/server/wishlist.ts

@@ -0,0 +1,64 @@
+"use server";
+
+import { HttpTypes } from "@medusajs/types";
+import { sdk } from "../config";
+import { getRegion } from "./regions";
+import { fetchWishlist } from "medusa-wishlist-logic/server";
+
+/** Wishlist entries enriched with full Medusa product payloads. */
+export async function getWishlist(includeDetails = true, countryCode?: string) {
+    const result = await fetchWishlist(includeDetails);
+    if (!result.success) {
+        return { success: false as const, error: result.error, data: [] as unknown[] };
+    }
+
+    let wishlistItems = result.data as Array<Record<string, unknown>>;
+
+    if (!includeDetails || wishlistItems.length === 0) {
+        return { success: true as const, data: wishlistItems };
+    }
+
+    const productIds = wishlistItems
+        .map((item) => {
+            const id = item.product_id ?? item.id;
+            return typeof id === "string" ? id : null;
+        })
+        .filter((id): id is string => Boolean(id));
+
+    if (productIds.length === 0) {
+        return { success: true as const, data: wishlistItems };
+    }
+
+    try {
+        let regionId: string | undefined;
+        if (countryCode) {
+            const region = await getRegion(countryCode);
+            regionId = region?.id;
+        }
+
+        const productsResponse = await sdk.store.product.list(
+            {
+                id: productIds,
+                fields:
+                    "*thumbnail,*images,*variants,*variants.options,*options,*options.values,*variants.calculated_price,*variants.inventory_quantity,*variants.manage_inventory,*variants.allow_backorder",
+                ...(regionId ? { region_id: regionId } : {}),
+            },
+            { next: { tags: ["products"] } }
+        );
+
+        const fullProducts = productsResponse.products as HttpTypes.StoreProduct[];
+
+        wishlistItems = wishlistItems.map((item) => {
+            const itemId = (item.product_id ?? item.id) as string;
+            const fullProduct = fullProducts.find((p) => p.id === itemId);
+            if (fullProduct) {
+                return { ...item, product: fullProduct };
+            }
+            return item;
+        });
+    } catch {
+        // Return API wishlist without enrichment
+    }
+
+    return { success: true as const, data: wishlistItems };
+}

package/src/services/middleware.ts

@@ -0,0 +1,54 @@
+/** Edge-safe Medusa store fetches (no Node SDK). */
+
+export interface MedusaMiddlewareClientOptions {
+    backendUrl: string;
+    publishableApiKey: string;
+}
+
+function normalizeBackendUrl(backendUrl: string): string {
+    return backendUrl.replace(/\/$/, "");
+}
+
+export async function medusaListRegions(
+    options: MedusaMiddlewareClientOptions,
+    init?: RequestInit
+): Promise<{ regions: unknown[] }> {
+    const url = `${normalizeBackendUrl(options.backendUrl)}/store/regions`;
+    const response = await fetch(url, {
+        ...init,
+        headers: {
+            "x-publishable-api-key": options.publishableApiKey,
+            ...(init?.headers as Record<string, string> | undefined),
+        },
+    });
+
+    const json = (await response.json()) as { regions?: unknown[]; message?: string };
+    if (!response.ok) {
+        throw new Error(json.message || "Failed to fetch regions");
+    }
+    return { regions: json.regions ?? [] };
+}
+
+export async function medusaMergeCarts(
+    options: MedusaMiddlewareClientOptions & {
+        authorization: string;
+        cartId?: string;
+    },
+    init?: RequestInit
+): Promise<Response> {
+    const url = `${normalizeBackendUrl(options.backendUrl)}/store/carts/merge`;
+    return fetch(url, {
+        method: "POST",
+        ...init,
+        headers: {
+            "Content-Type": "application/json",
+            "x-publishable-api-key": options.publishableApiKey,
+            Authorization: options.authorization.startsWith("Bearer ")
+                ? options.authorization
+                : `Bearer ${options.authorization}`,
+            ...(init?.headers as Record<string, string> | undefined),
+        },
+        body: options.cartId ? JSON.stringify({ cart_id: options.cartId }) : init?.body,
+        cache: init?.cache ?? "no-store",
+    });
+}

package/src/util/get-locale-header.ts

@@ -0,0 +1,8 @@
+import { getLocale } from "../server/locale-actions"
+
+export async function getLocaleHeader() {
+  const locale = await getLocale()
+  return {
+    "x-medusa-locale": locale,
+  } as const
+}

package/src/util/medusa-error.ts

@@ -0,0 +1,19 @@
+export default function medusaError(error: any): never {
+  if (error.response) {
+    // The request was made and the server responded with a status code
+    // that falls out of the range of 2xx
+    const u = new URL(error.config.url, error.config.baseURL)
+
+
+    // Extracting the error message from the response data
+    const message = error.response.data.message || error.response.data
+
+    throw new Error(message.charAt(0).toUpperCase() + message.slice(1) + ".")
+  } else if (error.request) {
+    // The request was made but no response was received
+    throw new Error("No response received: " + error.request)
+  } else {
+    // Something happened in setting up the request that triggered an Error
+    throw new Error("Error setting up the request: " + error.message)
+  }
+}

package/src/util/sort-products.ts

@@ -0,0 +1,47 @@
+import { HttpTypes } from "@medusajs/types";
+
+export type SortOptions =
+    | "price_asc"
+    | "price_desc"
+    | "created_at_desc"
+    | "created_at_asc"
+    | "bestsellers"
+    | "created_at";
+
+interface MinPricedProduct extends HttpTypes.StoreProduct {
+    _minPrice?: number;
+}
+
+export function sortProducts(
+    products: HttpTypes.StoreProduct[],
+    sortBy: SortOptions
+): HttpTypes.StoreProduct[] {
+    const sortedProducts = products as MinPricedProduct[];
+
+    if (["price_asc", "price_desc"].includes(sortBy)) {
+        sortedProducts.forEach((product) => {
+            if (product.variants && product.variants.length > 0) {
+                product._minPrice = Math.min(
+                    ...product.variants.map(
+                        (variant) => variant?.calculated_price?.calculated_amount || 0
+                    )
+                );
+            } else {
+                product._minPrice = Infinity;
+            }
+        });
+
+        sortedProducts.sort((a, b) => {
+            const diff = a._minPrice! - b._minPrice!;
+            return sortBy === "price_asc" ? diff : -diff;
+        });
+    }
+
+    if (sortBy === "created_at") {
+        sortedProducts.sort((a, b) => {
+            return new Date(b.created_at!).getTime() - new Date(a.created_at!).getTime();
+        });
+    }
+
+    return sortedProducts;
+}