medusa-storefront-data 1.0.0 → 2.0.0

package/src/server/returns.ts

@@ -1,29 +1,22 @@
 "use server"
 
-import { sdk } from "../config"
+import {
+  medusaReturnCreate,
+  medusaReturnCreateGuest,
+  medusaReturnList,
+  medusaReturnListGuest,
+  medusaReturnReasonList,
+  medusaReturnShippingOptionsResolve,
+  medusaReturnUpdatePayment,
+} from "medusa-services/returns"
 import { HttpTypes } from "@medusajs/types"
 import { cookies } from "next/headers"
-import { getAuthHeaders, getCacheOptions } from "../cookies"
 import { revalidateTag } from "next/cache"
+import { getStoreClientOptions, getStoreClientOptionsWithToken } from "../util/store-client"
 
 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(() => [])
+  const options = await getStoreClientOptions()
+  return medusaReturnReasonList(options)
 }
 
 export const listReturnShippingOptions = async (
@@ -31,72 +24,12 @@ export const listReturnShippingOptions = async (
   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 []
+  const options = await getStoreClientOptions()
+  const shippingOptions = await medusaReturnShippingOptionsResolve(options, {
+    cartId,
+    regionId,
+  })
+  return shippingOptions as unknown as HttpTypes.StoreShippingOption[]
 }
 
 export const createReturnRequest = async (
@@ -120,10 +53,10 @@ export const createReturnRequest = async (
   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[] = []
+  let items: Array<{ id: string; quantity: number; return_reason_id?: string; location_id?: string }> = []
   try {
     items = JSON.parse(itemsJson)
-  } catch (e) {
+  } catch {
     return { success: false, error: "Invalid items data", return: null }
   }
 
@@ -131,91 +64,67 @@ export const createReturnRequest = async (
     return { success: false, error: "At least one item must be selected", return: null }
   }
 
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
+  const options = await getStoreClientOptions()
 
   try {
-    // Standard Medusa v2 payload
-    const payload: any = {
+    const payload = {
       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,
+        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",
+      ...(returnShippingOptionId
+        ? {
+            return_shipping: {
+              option_id: returnShippingOptionId,
+              location_id: locationId || items[0]?.location_id || "default_location",
+            },
+          }
+        : {}),
+      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 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
+        const guestOptions = await getStoreClientOptionsWithToken(guestToken)
+        returnData = (await medusaReturnCreateGuest(
+          orderId,
+          payload,
+          guestOptions
+        )) as unknown as HttpTypes.StoreReturn
+      } catch {
+        returnData = (await medusaReturnCreate(
+          payload,
+          options
+        )) as unknown as HttpTypes.StoreReturn
       }
     } 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
+      returnData = (await medusaReturnCreate(
+        payload,
+        options
+      )) as unknown as HttpTypes.StoreReturn
     }
 
     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 }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to create return request",
+      return: null,
+    }
   }
 }
 
@@ -223,24 +132,17 @@ export const createReturnRequest = async (
  * Link a payment method to a return (for Refund Destination)
  */
 export const updateReturnPayment = async (returnId: string, paymentId: string) => {
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
+  const options = await getStoreClientOptions()
 
   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) {
+    const data = await medusaReturnUpdatePayment(returnId, paymentId, options)
+    return { success: true, data }
+  } catch (error) {
     console.error("Update return payment fail:", error)
-    return { success: false, error: error.message }
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    }
   }
 }
 
@@ -248,43 +150,27 @@ export const updateReturnPayment = async (returnId: string, paymentId: string) =
  * List returns for an order or customer
  */
 export const listReturns = async (orderId?: string) => {
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
+  const options = await getStoreClientOptions()
 
-  // Authenticated flow
-  const authHeaders = headers as any
-  if (authHeaders.authorization || authHeaders.Authorization) {
+  if (options.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 await medusaReturnList(options, orderId ? { order_id: orderId } : undefined)
+    } catch {
       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
+    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) {
+        const guestOptions = await getStoreClientOptionsWithToken(guestToken)
+        return await medusaReturnListGuest(orderId, guestOptions)
+      } catch {
         return { returns: [], count: 0 }
       }
     }

package/src/server/swaps.ts

@@ -1,150 +1,119 @@
-
 "use server"
 
-import { sdk } from "../config"
-import { HttpTypes } from "@medusajs/types"
+import {
+  medusaSwapCreate,
+  medusaSwapCreateGuest,
+  medusaSwapList,
+  medusaSwapListGuest,
+} from "medusa-services/swaps"
 import { cookies } from "next/headers"
-import { getAuthHeaders } from "../cookies"
 import { revalidateTag } from "next/cache"
+import { getStoreClientOptions, getStoreClientOptionsWithToken } from "../util/store-client"
 
 /**
  * Create an exchange (swap) request.
  * Supports both authenticated customers and guest users.
  */
 export const createSwapRequest = async (
-    prevState: any,
-    formData: FormData
+  prevState: unknown,
+  formData: FormData
 ): Promise<{
-    success: boolean
-    error: string | null
-    swap: any | null
+  success: boolean
+  error: string | null
+  swap: Record<string, unknown> | 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 }
+  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: Array<Record<string, unknown>> = []
+  let newItems: Array<Record<string, unknown>> = []
+  try {
+    returnItems = JSON.parse(returnItemsJson)
+    newItems = JSON.parse(newItemsJson)
+  } catch {
+    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 options = await getStoreClientOptions()
+
+  try {
+    const payload = {
+      order_id: orderId,
+      return_items: returnItems,
+      new_items: newItems,
+      reason: reason || "Size exchange",
+      note: note || "Exchange requested from storefront",
     }
 
-    if (returnItems.length === 0) {
-        return { success: false, error: "At least one item must be selected for return", swap: null }
+    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: Record<string, unknown>
+
+    if (guestToken && !token) {
+      const guestOptions = await getStoreClientOptionsWithToken(guestToken)
+      swapData = await medusaSwapCreateGuest(
+        orderId,
+        {
+          return_items: payload.return_items,
+          new_items: payload.new_items,
+          reason: payload.reason,
+          note: payload.note,
+        },
+        guestOptions
+      )
+    } else {
+      swapData = await medusaSwapCreate(payload, options)
     }
 
-    const headers = {
-        ...(await getAuthHeaders()),
-    }
+    revalidateTag("orders")
 
-    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 }
+    return { success: true, error: null, swap: swapData }
+  } catch (error) {
+    let errorMsg = "Failed to create exchange request"
+    if (error instanceof Error && 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()),
-    }
+  const options = await getStoreClientOptions()
 
-    // 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",
-        })
-    }
+  if (options.authorization) {
+    return medusaSwapList(options, orderId ? { order_id: orderId } : undefined)
+  }
+
+  if (orderId) {
+    const cookieStore = await cookies()
+    const guestToken =
+      cookieStore.get("_medusa_guest_jwt")?.value ||
+      cookieStore.get("_medusa_guest_token")?.value
 
-    // 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",
-            })
-        }
+    if (guestToken) {
+      const guestOptions = await getStoreClientOptionsWithToken(guestToken)
+      return medusaSwapListGuest(orderId, guestOptions)
     }
+  }
 
-    return { swaps: [], count: 0 }
+  return { swaps: [], count: 0 }
 }

package/src/server/variants.ts

@@ -1,38 +1,19 @@
 "use server"
 
-import { sdk } from "../config"
 import { HttpTypes } from "@medusajs/types"
-
-import { getAuthHeaders, getCacheOptions } from "../cookies"
+import { medusaVariantRetrieve } from "medusa-services/variants"
+import { getStoreClientOptions } from "../util/store-client"
 
 export const retrieveVariant = async (
   variant_id: string
 ): Promise<HttpTypes.StoreProductVariant | null> => {
-  const authHeaders = await getAuthHeaders()
-
-  if (!authHeaders) return null
+  try {
+    const options = await getStoreClientOptions()
+    if (!options.authorization) return null
 
-  const headers = {
-    ...authHeaders,
+    const { variant } = await medusaVariantRetrieve(variant_id, options, { fields: "*images" })
+    return variant as unknown as HttpTypes.StoreProductVariant
+  } catch {
+    return null
   }
-
-  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/util/revalidate-cart.ts

@@ -0,0 +1,10 @@
+import { revalidateTag } from "next/cache"
+import { getCacheTag } from "../cookies"
+
+export async function revalidateCartTags(): Promise<void> {
+  const cartCacheTag = await getCacheTag("carts")
+  revalidateTag(cartCacheTag)
+
+  const fulfillmentCacheTag = await getCacheTag("fulfillment")
+  revalidateTag(fulfillmentCacheTag)
+}