@pradip1995/commerce-core 1.0.0

package/src/data/returns.ts

@@ -0,0 +1,305 @@
+"use server"
+
+import { sdk } from "@core/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/data/reviews.ts

@@ -0,0 +1,279 @@
+"use server"
+
+import { sdk } from "@core/config"
+import { getAuthHeaders } from "./cookies"
+
+type SubmitReviewParams = {
+  product_id: string
+  rating: number
+  title: string
+  description: string
+  images?: string[]
+}
+
+export async function submitReview(params: SubmitReviewParams) {
+  try {
+    // Server actions kabhi–kabhi stringified JSON bhi receive kar sakte hain.
+    // Defensive: agar string mile to pehle parse karke proper object bana lo.
+    const normalizedParams: SubmitReviewParams =
+      typeof params === "string" ? JSON.parse(params) : params
+
+    const authHeaders = await getAuthHeaders()
+    const publishableKey = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY
+
+    if (!publishableKey) {
+      return {
+        success: false,
+        error: "Configuration error: Publishable API key is missing.",
+      }
+    }
+
+    if (!authHeaders || !("authorization" in authHeaders)) {
+      return {
+        success: false,
+        error: "Please login to submit a review.",
+      }
+    }
+
+    // Get base URL from environment
+    const baseUrl = process.env.MEDUSA_BACKEND_URL || "http://localhost:9000"
+
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      "x-publishable-api-key": publishableKey,
+      ...authHeaders,
+    }
+
+    const response = await fetch(`${baseUrl}/store/reviews`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        product_id: normalizedParams.product_id,
+        rating: normalizedParams.rating,
+        title: normalizedParams.title,
+        description: normalizedParams.description,
+        images: normalizedParams.images || [],
+      }),
+    })
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: "Unknown error" }))
+      return {
+        success: false,
+        error: error.message || `HTTP ${response.status}: Failed to submit review`,
+      }
+    }
+
+    const data = await response.json()
+    return {
+      success: true,
+      data,
+    }
+  } catch (error: any) {
+    return {
+      success: false,
+      error:
+        error.message ||
+        error.error?.message ||
+        "An error occurred while submitting the review",
+    }
+  }
+}
+
+type UpdateReviewParams = {
+  id: string
+  rating?: number
+  title?: string
+  description?: string
+  images?: string[]
+}
+
+export async function updateReview(params: UpdateReviewParams) {
+  try {
+    const normalizedParams: UpdateReviewParams =
+      typeof params === "string" ? JSON.parse(params) : params
+
+    const authHeaders = await getAuthHeaders()
+    const publishableKey = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY
+
+    if (!publishableKey) {
+      return {
+        success: false,
+        error: "Configuration error: Publishable API key is missing.",
+      }
+    }
+
+    if (!authHeaders || !("authorization" in authHeaders)) {
+      return { success: false, error: "Please login to update your review." }
+    }
+
+    const baseUrl = process.env.MEDUSA_BACKEND_URL || "http://localhost:9000"
+
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      "x-publishable-api-key": publishableKey,
+      ...authHeaders,
+    }
+
+    const response = await fetch(`${baseUrl}/store/reviews/${normalizedParams.id}`, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify({
+        rating: normalizedParams.rating,
+        title: normalizedParams.title,
+        description: normalizedParams.description,
+        images: normalizedParams.images,
+      }),
+    })
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: "Unknown error" }))
+      return {
+        success: false,
+        error: error.message || `HTTP ${response.status}: Failed to update review`,
+      }
+    }
+
+    const data = await response.json()
+    return {
+      success: true,
+      data,
+    }
+  } catch (error: any) {
+    return {
+      success: false,
+      error:
+        error.message ||
+        error.error?.message ||
+        "An error occurred while updating the review",
+    }
+  }
+}
+
+// SERVER ACTION: Fetch Reviews on the Server (Logs will appear in Terminal)
+export async function fetchReviewsForProduct(productId: string) {
+  const backendUrl = process.env.MEDUSA_BACKEND_URL || "http://localhost:9000"
+  const publishableKey = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY
+
+  try {
+    if (!publishableKey) return []
+
+    const url = new URL(`${backendUrl}/store/products/${productId}/reviews`)
+    url.searchParams.set("status", "approved")
+    url.searchParams.set("limit", "50")
+
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "x-publishable-api-key": publishableKey,
+      },
+      cache: "no-store",
+    })
+
+    if (response.ok) {
+      const data = await response.json()
+      return data.reviews || []
+    }
+    return []
+  } catch (error) {
+    return []
+  }
+}
+
+// Check if current authenticated customer has already reviewed the product
+export async function checkCustomerReviewStatus(productId: string) {
+  try {
+    const authHeaders = await getAuthHeaders()
+    const publishableKey = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY
+    const backendUrl = process.env.MEDUSA_BACKEND_URL || "http://localhost:9000"
+
+    if (!publishableKey || !authHeaders || !("authorization" in authHeaders)) {
+      return { hasReviewed: false }
+    }
+
+    const response = await fetch(
+      `${backendUrl}/store/products/${productId}/reviews/me`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          "x-publishable-api-key": publishableKey,
+          ...authHeaders,
+        },
+        cache: "no-store",
+      }
+    )
+
+    if (response.ok) {
+      const data = await response.json()
+      return {
+        hasReviewed:
+          data.hasReviewed || (data.summary && data.summary.total_reviews > 0),
+        reviews: data.reviews || [],
+        canAddReview: data.canAddReview,
+      }
+    }
+
+    return { hasReviewed: false }
+  } catch (error) {
+    return { hasReviewed: false }
+  }
+}
+
+export async function fetchRatings() {
+  const backendUrl = process.env.MEDUSA_BACKEND_URL || "http://localhost:9000"
+  const publishableKey = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY
+
+  try {
+    if (!publishableKey) return []
+
+    const response = await fetch(`${backendUrl}/store/ratings`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "x-publishable-api-key": publishableKey,
+      },
+      cache: "no-store",
+    })
+
+    if (response.ok) {
+      const data = await response.json()
+      return data.rating || []
+    }
+    return []
+  } catch (error) {
+    return []
+  }
+}
+export async function fetchRatingForProduct(productId: string) {
+  const backendUrl = process.env.MEDUSA_BACKEND_URL || "http://localhost:9000"
+  const publishableKey = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY
+
+  try {
+    if (!publishableKey) return null
+
+    const response = await fetch(
+      `${backendUrl}/store/ratings?product_id=${productId}`,
+      {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          "x-publishable-api-key": publishableKey,
+        },
+        cache: "no-store",
+      }
+    )
+
+    if (response.ok) {
+      const data = await response.json()
+      // The API returns { rating: [...] }
+      if (data.rating && data.rating.length > 0) {
+        return data.rating[0]
+      }
+    }
+    return null
+  } catch (error) {
+    return null
+  }
+}