medusa-storefront-data 1.0.0 → 2.1.0

package/src/server/fulfillment.ts

@@ -1,8 +1,14 @@
 "use server"
 
+import type { FetchArgs } from "@medusajs/js-sdk"
 import { sdk } from "../config"
 import { HttpTypes } from "@medusajs/types"
 import { getAuthHeaders, getCacheOptions } from "../cookies"
+import {
+  medusaShippingOptionCalculate,
+  medusaShiprocketServiceability,
+} from "medusa-services/fulfillment"
+import { getStoreCartClientOptions } from "../util/store-client"
 
 export const listCartShippingMethods = async (cartId: string) => {
   const headers = {
@@ -24,7 +30,7 @@ export const listCartShippingMethods = async (cartId: string) => {
         headers,
         next,
         cache: "force-cache",
-      }
+      } as FetchArgs & { next?: typeof next; cache?: RequestCache }
     )
     .then(({ shipping_options }) => shipping_options)
     .catch(() => {
@@ -37,61 +43,29 @@ export const calculatePriceForShippingOption = async (
   cartId: string,
   data?: Record<string, unknown>
 ) => {
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
-
-  const next = {
-    ...(await getCacheOptions("fulfillment")),
-  }
-
-  const body = { cart_id: cartId, data }
-
-  if (data) {
-    body.data = data
-  }
-
-  return sdk.client
-    .fetch<{ shipping_option: HttpTypes.StoreCartShippingOption }>(
-      `/store/shipping-options/${optionId}/calculate`,
-      {
-        method: "POST",
-        body,
-        headers,
-        next,
-      }
+  try {
+    const options = await getStoreCartClientOptions()
+    const { shipping_option } = await medusaShippingOptionCalculate(
+      optionId,
+      cartId,
+      options,
+      data
     )
-    .then(({ shipping_option }) => shipping_option)
-    .catch((e) => {
-      return null
-    })
+    return shipping_option as unknown as HttpTypes.StoreCartShippingOption
+  } catch (e) {
+    return null
+  }
 }
 
 export const getShiprocketServiceability = async (pincode: string, variant_id: string, cod: number = 0) => {
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
-
-  return sdk.client
-    .fetch<any>(
-      `/store/shiprocket/serviceability`,
-      {
-        method: "GET",
-        query: {
-          pincode,
-          variant_id,
-          cod: cod.toString(),
-        },
-        headers,
-        cache: "no-store",
-      }
+  try {
+    const options = await getStoreCartClientOptions()
+    return await medusaShiprocketServiceability(
+      { pincode, variant_id, cod },
+      options
     )
-    .then((data) => data)
-    .catch(async (e) => {
-      if (e.response) {
-        const errorData = await e.response.json()
-        throw new Error(errorData.message || "Failed to check serviceability")
-      }
-      throw e
-    })
+  } catch {
+    // Missing variant dimensions or Shiprocket unavailable — checkout must continue.
+    return null
+  }
 }

package/src/server/guest.ts

@@ -1,333 +1,216 @@
 "use server"
 
+import {
+  medusaGuestOrderCancelSimple,
+  medusaGuestOrderInvoice,
+  medusaGuestOrderList,
+  medusaGuestOrderRetrieve,
+  medusaGuestOtpRequest,
+  medusaGuestOtpVerify,
+  type GuestReturnItem,
+} from "medusa-services/guest"
+import { medusaGuestOrderReorder } from "medusa-services/orders"
+import { medusaReturnCreateGuest } from "medusa-services/returns"
 import { cookies, headers } from "next/headers"
-import { getGuestAuthHeaders } from "../cookies"
-import { sdk } from "../config"
+import {
+  getStoreClientOptions,
+  getStoreClientOptionsWithToken,
+} from "../util/store-client"
+import { retrieveOrder } from "./orders"
+
+async function resolveGuestToken(token?: string): Promise<string | null> {
+  if (token) return token
 
-const BACKEND_URL = process.env.NEXT_PUBLIC_MEDUSA_BACKEND_URL || "http://localhost:9000"
-const PUBLISHABLE_KEY = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY
+  const headersStore = await headers()
+  const authHeader = headersStore.get("authorization")
+  const headerToken = authHeader?.startsWith("Bearer ") ? authHeader.split(" ")[1] : undefined
+  if (headerToken) return headerToken
+
+  const cookieStore = await cookies()
+  return cookieStore.get("_medusa_guest_jwt")?.value ?? null
+}
 
 /**
  * Compatibility wrapper for sendOTP
  */
 export async function sendOTP(email: string, type: string = "email_verification") {
-    const res = await requestGuestOTP(email)
-    // The previous project expected a token or success. 
-    // We return a dummy token if successful because the UI checks for it.
-    if (res.success) {
-        return { success: true, token: "otp_sent_successfully" }
-    }
-    return res
+  const options = await getStoreClientOptions()
+  const res = await medusaGuestOtpRequest(email, options)
+  if (res.success) {
+    return { success: true, token: "otp_sent_successfully" }
+  }
+  return res
 }
 
 /**
  * Compatibility wrapper for verifyOTP
  */
 export async function verifyOTP(email: string, token: string, otp: string) {
-    // The previous implementation used 3 args, but guest.ts uses 2.
-    // We ignore the mid 'token' as per user's working code.
-    return await verifyGuestOTP(email, otp)
+  return verifyGuestOTP(email, otp)
 }
 
-import { retrieveOrder } from "./orders"
-
 /**
  * Compatibility wrapper for listGuestOrders
  */
 export async function listGuestOrders(token: string) {
-    const res = await getGuestOrders(token)
-    if (!res.success) {
-        throw new Error(res.error || "Failed to fetch orders")
-    }
-
-    // Fetch full details for each order to ensure latest fulfillment_status is available
-    // because the custom list endpoint might not return all fields correctly.
-    const fullOrders = await Promise.all(
-        (res.orders || []).map(async (order: any) => {
-            try {
-                return await retrieveOrder(order.id)
-            } catch (e) {
-                return order
-            }
-        })
-    )
+  const res = await getGuestOrders(token)
+  if (!res.success) {
+    throw new Error(res.error || "Failed to fetch orders")
+  }
+
+  const fullOrders = await Promise.all(
+    (res.orders || []).map(async (order: { id?: string }) => {
+      try {
+        return await retrieveOrder(order.id!)
+      } catch {
+        return order
+      }
+    })
+  )
 
-    return { orders: fullOrders, count: fullOrders.length }
+  return { orders: fullOrders, count: fullOrders.length }
 }
 
 export async function requestGuestOTP(email: string) {
-    const headers: Record<string, string> = {
-        "Content-Type": "application/json",
-    }
-    if (PUBLISHABLE_KEY) headers["x-publishable-api-key"] = PUBLISHABLE_KEY
-
-    try {
-        const res = await fetch(`${BACKEND_URL}/store/otp/request`, {
-            method: "POST",
-            headers,
-            body: JSON.stringify({ email }),
-            cache: "no-store",
-        })
-
-        if (!res.ok) {
-            const errorData = await res.json().catch(() => ({}))
-            throw new Error(errorData.message || "Failed to send OTP")
-        }
-        return { success: true }
-    } catch (error: any) {
-        return { success: false, error: error.message }
-    }
+  const options = await getStoreClientOptions()
+  return medusaGuestOtpRequest(email, options)
 }
 
 export async function verifyGuestOTP(email: string, otp: string) {
-    const headers: Record<string, string> = {
-        "Content-Type": "application/json",
-    }
-    if (PUBLISHABLE_KEY) headers["x-publishable-api-key"] = PUBLISHABLE_KEY
-
-    try {
-        const res = await fetch(`${BACKEND_URL}/store/otp/verify`, {
-            method: "POST",
-            headers,
-            body: JSON.stringify({ email, otp }),
-            cache: "no-store",
-        })
+  const options = await getStoreClientOptions()
+  const res = await medusaGuestOtpVerify(email, otp, options)
 
-        if (!res.ok) {
-            const errorData = await res.json().catch(() => ({}))
-            throw new Error(errorData.message || "Failed to verify OTP")
-        }
-
-        const data = await res.json()
-
-        if (data.token) {
-            const cookieStore = await cookies()
-            cookieStore.set("_medusa_guest_jwt", data.token, {
-                httpOnly: true,
-                secure: process.env.NODE_ENV === "production",
-                maxAge: 60 * 60 * 24, // 1 day
-                path: "/",
-            })
-        } else {
-            throw new Error("No token returned")
-        }
+  if (res.success && res.token) {
+    const cookieStore = await cookies()
+    cookieStore.set("_medusa_guest_jwt", res.token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      maxAge: 60 * 60 * 24,
+      path: "/",
+    })
+  }
 
-        return { success: true, token: data.token }
-    } catch (error: any) {
-        return { success: false, error: error.message }
-    }
+  return res
 }
 
 export async function logoutGuest() {
-    const cookieStore = await cookies()
-    cookieStore.set("_medusa_guest_jwt", "", {
-        maxAge: -1,
-        path: "/",
-    })
-    return { success: true }
+  const cookieStore = await cookies()
+  cookieStore.set("_medusa_guest_jwt", "", {
+    maxAge: -1,
+    path: "/",
+  })
+  return { success: true }
 }
 
 export async function getGuestOrders(token?: string) {
-    const cookieStore = await cookies()
-    const headersStore = await headers()
-    const authHeader = headersStore.get("authorization")
-    const headerToken = authHeader?.startsWith("Bearer ") ? authHeader.split(" ")[1] : undefined
-
-    const authToken = token || headerToken || cookieStore.get("_medusa_guest_jwt")?.value
-    if (!authToken) return { success: false, error: "Unauthorized" }
-
-    const requestHeaders: Record<string, string> = {
-        "Authorization": `Bearer ${authToken}`
-    }
-    if (PUBLISHABLE_KEY) requestHeaders["x-publishable-api-key"] = PUBLISHABLE_KEY
-
-    try {
-        const response = await sdk.client.fetch<any>(`/store/guest-orders`, {
-            method: "GET",
-            headers: requestHeaders,
-            query: {
-                fields: "id,display_id,status,fulfillment_status,payment_status,created_at,currency_code,total,subtotal,tax_total,shipping_total,discount_total,metadata,email,*items,*items.variant,*items.variant.product"
-            },
-            cache: "no-store",
-        })
-
-        return { success: true, orders: response.orders || [] }
-    } catch (error: any) {
-        return { success: false, error: error.message }
-    }
+  const authToken = await resolveGuestToken(token)
+  if (!authToken) return { success: false, error: "Unauthorized" }
+
+  try {
+    const options = await getStoreClientOptions()
+    const response = await medusaGuestOrderList(authToken, options)
+    return { success: true, orders: response.orders || [] }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
 }
 
 export async function getGuestOrder(id: string, token?: string) {
-    const cookieStore = await cookies()
-    const headersStore = await headers()
-    const authHeader = headersStore.get("authorization")
-    const headerToken = authHeader?.startsWith("Bearer ") ? authHeader.split(" ")[1] : undefined
+  const authToken = await resolveGuestToken(token)
+  if (!authToken) return { success: false, error: "Unauthorized" }
 
-    const authToken = token || headerToken || cookieStore.get("_medusa_guest_jwt")?.value
-    if (!authToken) return { success: false, error: "Unauthorized" }
+  try {
+    const options = await getStoreClientOptions()
+    const response = await medusaGuestOrderRetrieve(id, authToken, options)
 
-    const requestHeaders: Record<string, string> = {
-        "Authorization": `Bearer ${authToken}`
+    if (response.order) {
+      return { success: true, order: response.order }
     }
-    if (PUBLISHABLE_KEY) requestHeaders["x-publishable-api-key"] = PUBLISHABLE_KEY
-
-    try {
-        const response = await sdk.client.fetch<any>(`/store/orders/${id}`, {
-            method: "GET",
-            headers: requestHeaders,
-            query: {
-                fields: "*payment_collections.payments,*items,*items.metadata,*items.variant,*items.variant.images,*items.variant.product,*items.variant.product.thumbnail,*items.variant.product.images,*items.product,*items.product.thumbnail,*items.product.images,*fulfillments,*fulfillments.items,*fulfillments.location_id,*returns,*returns.items,*cart,*shipping_address,*billing_address,*region,*shipping_methods"
-            },
-            cache: "no-store"
-        })
-
-        if (response.order) {
-            return { success: true, order: response.order }
-        } else {
-            return { success: false, error: "Order not found" }
-        }
-    } catch (error: any) {
-        return { success: false, error: error.message }
+    return { success: false, error: "Order not found" }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
     }
+  }
 }
 
 export async function cancelGuestOrder(orderId: string, token?: string) {
-    const authHeaders = await getGuestAuthHeaders()
-    const authToken = token || (authHeaders as any).authorization?.split(" ")[1]
-
-    if (!authToken) return { success: false, error: "Unauthorized" }
-
-    const requestHeaders: Record<string, string> = {
-        "Authorization": `Bearer ${authToken}`
-    }
-    if (PUBLISHABLE_KEY) requestHeaders["x-publishable-api-key"] = PUBLISHABLE_KEY
-
-    try {
-        const response = await fetch(`${BACKEND_URL}/store/guest-orders/${orderId}/cancel`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...requestHeaders
-            },
-            cache: "no-store",
-        })
-
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}))
-            throw new Error(errorData.message || "Failed to cancel order")
-        }
+  const authToken = await resolveGuestToken(token)
+  if (!authToken) return { success: false, error: "Unauthorized" }
 
-        return { success: true }
-    } catch (error: any) {
-        return { success: false, error: error.message }
+  try {
+    const options = await getStoreClientOptions()
+    await medusaGuestOrderCancelSimple(orderId, authToken, options)
+    return { success: true }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
     }
+  }
 }
 
 export async function getGuestOrderInvoice(orderId: string, token?: string) {
-    const authHeaders = await getGuestAuthHeaders()
-    const authToken = token || (authHeaders as any).authorization?.split(" ")[1]
-
-    if (!authToken) return { success: false, error: "Unauthorized" }
-
-    const requestHeaders: Record<string, string> = {
-        "Authorization": `Bearer ${authToken}`
-    }
-    if (PUBLISHABLE_KEY) requestHeaders["x-publishable-api-key"] = PUBLISHABLE_KEY
-
-    try {
-        const response = await fetch(`${BACKEND_URL}/store/guest/invoice/download/${orderId}`, {
-            method: "GET",
-            headers: requestHeaders,
-            cache: "no-store",
-        })
-
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}))
-            throw new Error(errorData.message || "Failed to get invoice")
-        }
-
-        const contentType = response.headers.get("content-type")
-        if (contentType && contentType.includes("application/pdf")) {
-            const arrayBuffer = await response.arrayBuffer()
-            const base64 = Buffer.from(arrayBuffer).toString('base64')
-            return { success: true, type: 'pdf', data: base64 }
-        } else {
-            const data = await response.json()
-            return { success: true, type: 'json', data }
-        }
-
-    } catch (error: any) {
-        return { success: false, error: error.message }
-    }
+  const authToken = await resolveGuestToken(token)
+  if (!authToken) return { success: false, error: "Unauthorized" }
+
+  try {
+    const options = await getStoreClientOptions()
+    const result = await medusaGuestOrderInvoice(orderId, authToken, options)
+    return { success: true, ...result }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
 }
 
 export async function guestReorder(orderId: string, token?: string) {
-    const authHeaders = await getGuestAuthHeaders()
-    const authToken = token || (authHeaders as any).authorization?.split(" ")[1]
-
-    if (!authToken) return { success: false, error: "Unauthorized" }
-
-    const requestHeaders: Record<string, string> = {
-        "Authorization": `Bearer ${authToken}`
-    }
-    if (PUBLISHABLE_KEY) requestHeaders["x-publishable-api-key"] = PUBLISHABLE_KEY
-
-    try {
-        const response = await fetch(`${BACKEND_URL}/store/guest-orders/${orderId}/reorder`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...requestHeaders
-            },
-            cache: "no-store",
-        })
-
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}))
-            throw new Error(errorData.message || "Failed to reorder")
-        }
-
-        const data = await response.json()
-        return { success: true, data }
-    } catch (error: any) {
-        return { success: false, error: error.message }
-    }
+  const authToken = await resolveGuestToken(token)
+  if (!authToken) return { success: false, error: "Unauthorized" }
+
+  try {
+    const options = await getStoreClientOptionsWithToken(authToken)
+    const result = await medusaGuestOrderReorder(orderId, options)
+    if (!result.ok) {
+      throw new Error(
+        typeof result.data.message === "string"
+          ? result.data.message
+          : "Failed to reorder"
+      )
+    }
+    return { success: true, data: result.data }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
 }
 
-export async function createGuestReturn(orderId: string, items: { id: string, quantity: number }[], reason_id?: string, note?: string, token?: string) {
-    const authHeaders = await getGuestAuthHeaders()
-    const authToken = token || (authHeaders as any).authorization?.split(" ")[1]
-
-    if (!authToken) return { success: false, error: "Unauthorized" }
-
-    const requestHeaders: Record<string, string> = {
-        "Authorization": `Bearer ${authToken}`
-    }
-    if (PUBLISHABLE_KEY) requestHeaders["x-publishable-api-key"] = PUBLISHABLE_KEY
-
-    try {
-        const response = await fetch(`${BACKEND_URL}/store/guest-orders/${orderId}/returns`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...requestHeaders
-            },
-            body: JSON.stringify({
-                items,
-                reason_id,
-                note
-            }),
-            cache: "no-store",
-        })
-
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}))
-            throw new Error(errorData.message || "Failed to create return request")
-        }
-
-        const data = await response.json()
-        return { success: true, data }
-    } catch (error: any) {
-        return { success: false, error: error.message }
-    }
+export async function createGuestReturn(
+  orderId: string,
+  items: GuestReturnItem[],
+  reason_id?: string,
+  note?: string,
+  token?: string
+) {
+  const authToken = await resolveGuestToken(token)
+  if (!authToken) return { success: false, error: "Unauthorized" }
+
+  try {
+    const options = await getStoreClientOptionsWithToken(authToken)
+    const data = await medusaReturnCreateGuest(orderId, { items, reason_id, note }, options)
+    return { success: true, data }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
 }

package/src/server/home.ts

@@ -0,0 +1,68 @@
+"use server";
+
+import { listCollections } from "./collections";
+import { listCategories } from "./categories";
+import { listProductsWithSort, getProductsByTag } from "./products";
+import { getRegion } from "./regions";
+import { getTestimonialsFromConfig } from "./dynamic-config";
+import { fetchRatings } from "medusa-reviews-logic/server";
+
+export type HomePageData = {
+  region: Awaited<ReturnType<typeof getRegion>>;
+  collections: Array<Record<string, unknown>>;
+  categories: unknown[];
+  newArrivals: unknown[];
+  bestsellers: unknown[];
+  testimonials: unknown | null;
+  ratings: unknown[];
+};
+
+/**
+ * Parallel home page data loader (replaces per-page Promise.all boilerplate).
+ */
+export async function loadHomePageData(countryCode: string): Promise<HomePageData | null> {
+  const region = await getRegion(countryCode);
+  if (!region) return null;
+
+  const [
+    collectionsResult,
+    categoriesResult,
+    newArrivalsResult,
+    bestsellersResult,
+    testimonialsData,
+    allRatings,
+  ] = await Promise.all([
+    listCollections({ fields: "id, handle, title, metadata" }).catch(() => ({
+      collections: [],
+    })),
+    listCategories({ limit: 50 }).catch(() => []),
+    listProductsWithSort({
+      page: 1,
+      queryParams: { limit: 8 },
+      sortBy: "created_at",
+      countryCode,
+    }).catch(() => ({ response: { products: [] } })),
+    getProductsByTag({
+      tagValue: "bestseller",
+      limit: 10,
+      countryCode,
+    }).catch(() => []),
+    getTestimonialsFromConfig().catch(() => null),
+    fetchRatings(),
+  ]);
+
+  const collections =
+    (collectionsResult as { collections?: unknown[] }).collections ?? [];
+  const newArrivals =
+    (newArrivalsResult as { response?: { products?: unknown[] } }).response?.products ?? [];
+
+  return {
+    region,
+    collections: collections as Array<Record<string, unknown>>,
+    categories: categoriesResult ?? [],
+    newArrivals,
+    bestsellers: bestsellersResult ?? [],
+    testimonials: testimonialsData,
+    ratings: allRatings ?? [],
+  };
+}

package/src/server/index.ts

@@ -19,3 +19,4 @@ export * from "./returns"
 export * from "./swaps"
 export * from "./variants"
 export * from "./wishlist"
+export * from "./home"