@pradip1995/commerce-core 1.0.0

package/src/data/swaps.ts

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

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

@@ -0,0 +1,292 @@
+"use server"
+
+import { getAuthHeaders } from "./cookies"
+import { HttpTypes } from "@medusajs/types"
+
+const getBaseUrl = () => {
+  return process.env.MEDUSA_BACKEND_URL || "http://localhost:9000"
+}
+
+const getPublishableKey = () => {
+  return process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY
+}
+
+/**
+ * Add a product to wishlist
+ */
+export async function addToWishlist(productId: string) {
+  try {
+    const authHeaders = await getAuthHeaders()
+    const publishableKey = getPublishableKey()
+    const baseUrl = getBaseUrl()
+
+    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 add items to wishlist.",
+      }
+    }
+
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      "x-publishable-api-key": publishableKey,
+      ...authHeaders,
+    }
+
+    const response = await fetch(`${baseUrl}/store/wishlist`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        product_id: productId,
+      }),
+    })
+
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        return {
+          success: false,
+          error: "Login required",
+        }
+      }
+      const error = await response.json().catch(() => ({ message: "Unknown error" }))
+      return {
+        success: false,
+        error: error.message || `HTTP ${response.status}: Failed to add to wishlist`,
+      }
+    }
+
+    const data = await response.json()
+    return {
+      success: true,
+      data,
+    }
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message || "An error occurred while adding to wishlist",
+    }
+  }
+}
+
+/**
+ * Remove a product from wishlist
+ */
+export async function removeFromWishlist(productId: string) {
+  try {
+    const authHeaders = await getAuthHeaders()
+    const publishableKey = getPublishableKey()
+    const baseUrl = getBaseUrl()
+
+    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 remove items from wishlist.",
+      }
+    }
+
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      "x-publishable-api-key": publishableKey,
+      ...authHeaders,
+    }
+
+    const response = await fetch(`${baseUrl}/store/wishlist/${productId}`, {
+      method: "DELETE",
+      headers,
+    })
+
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        return {
+          success: false,
+          error: "Login required",
+        }
+      }
+      const error = await response.json().catch(() => ({ message: "Unknown error" }))
+      return {
+        success: false,
+        error:
+          error.message || `HTTP ${response.status}: Failed to remove from wishlist`,
+      }
+    }
+
+    return {
+      success: true,
+    }
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message || "An error occurred while removing from wishlist",
+    }
+  }
+}
+
+/**
+ * Get wishlist items with full product details
+ */
+export async function getWishlist(
+  includeDetails: boolean = true,
+  countryCode?: string
+) {
+  try {
+    const authHeaders = await getAuthHeaders()
+    const publishableKey = getPublishableKey()
+    const baseUrl = getBaseUrl()
+
+    if (!publishableKey) {
+      return {
+        success: false,
+        error: "Configuration error: Publishable API key is missing.",
+        data: [],
+      }
+    }
+
+    if (!authHeaders || !("authorization" in authHeaders)) {
+      // Return empty array if not logged in
+      return {
+        success: true,
+        data: [],
+      }
+    }
+
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      "x-publishable-api-key": publishableKey,
+      ...authHeaders,
+    }
+
+    const url = new URL(`${baseUrl}/store/wishlist`)
+    if (includeDetails) {
+      url.searchParams.set("include_details", "true")
+      // Using the same aggressive expansion style that worked for the cart
+      url.searchParams.set(
+        "fields",
+        "id,product_id,*product,product.thumbnail,product.images"
+      )
+    }
+
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers,
+      cache: "no-store",
+    })
+
+    if (!response.ok) {
+      // If 401 or 403, user is not authenticated, return empty array
+      if (response.status === 401 || response.status === 403) {
+        return {
+          success: true,
+          data: [],
+        }
+      }
+
+      const error = await response.json().catch(() => ({ message: "Unknown error" }))
+      return {
+        success: false,
+        error: error.message || `HTTP ${response.status}: Failed to fetch wishlist`,
+        data: [],
+      }
+    }
+
+    const data = await response.json()
+    let wishlistItems = data.wishlist || (Array.isArray(data) ? data : [])
+
+    // If we have items and details are requested, fetch full product details separately
+    if (includeDetails && wishlistItems.length > 0) {
+      const productIds = wishlistItems
+        .map((item: any) => item.product_id || item.id)
+        .filter(Boolean)
+
+      try {
+        const { sdk } = await import("@core/config")
+
+        let regionId: string | undefined = undefined
+        if (countryCode) {
+          const { getRegion } = await import("./regions")
+          const region = await getRegion(countryCode)
+          regionId = region?.id
+        }
+
+        const productsResponse = await sdk.store.product.list(
+          // Fetch comprehensive product details including variants, options and inventory for availability checks
+          {
+            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 unknown as HttpTypes.StoreProduct[]
+
+        // Merge full product data back into wishlist items
+        wishlistItems = wishlistItems.map((item: any) => {
+          const itemId = item.product_id || item.id
+          const fullProduct = fullProducts.find((p: any) => p.id === itemId)
+
+          if (fullProduct) {
+            // Prefer the full product data from the SDK as it has the relations we need
+            return {
+              ...item,
+              product: fullProduct,
+            }
+          }
+          return item
+        })
+      } catch (e) {
+        // Handle error silently
+      }
+    }
+
+    return {
+      success: true,
+      data: wishlistItems,
+    }
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message || "An error occurred while fetching wishlist",
+      data: [],
+    }
+  }
+}
+
+/**
+ * Get wishlist product IDs only (for checking if product is in wishlist)
+ */
+export async function getWishlistProductIds(): Promise<string[]> {
+  try {
+    const result = await getWishlist(false)
+    if (result.success && Array.isArray(result.data)) {
+      const ids = result.data
+        .map((item: any) => {
+          if (typeof item === "string") return item
+          if (item.product_id) return item.product_id
+          if (item.id) return item.id
+          if (item.product?.id) return item.product.id
+          return null
+        })
+        .filter((id: string | null): id is string => id !== null)
+      return ids
+    }
+    return []
+  } catch (error) {
+    return []
+  }
+}

package/src/domain/cart/abandoned-carts.ts

@@ -0,0 +1,49 @@
+import { HttpTypes } from "@medusajs/types"
+import { isBuyNowCart, isReorderCart } from "./metadata"
+
+export type AbandonedCartsResult = {
+  buyNowCarts: HttpTypes.StoreCart[]
+  reorderCarts: HttpTypes.StoreCart[]
+}
+
+export function filterOutCurrentCart(
+  carts: HttpTypes.StoreCart[],
+  currentCartId?: string | null
+): HttpTypes.StoreCart[] {
+  if (!currentCartId) {
+    return carts
+  }
+
+  return carts.filter((cart) => cart.id !== currentCartId)
+}
+
+export function partitionAbandonedCarts(
+  carts: HttpTypes.StoreCart[]
+): AbandonedCartsResult {
+  return {
+    buyNowCarts: carts.filter((cart) => isBuyNowCart(cart.metadata)),
+    reorderCarts: carts.filter((cart) => isReorderCart(cart.metadata)),
+  }
+}
+
+export function hasAbandonedCarts(abandoned: AbandonedCartsResult): boolean {
+  return abandoned.buyNowCarts.length > 0 || abandoned.reorderCarts.length > 0
+}
+
+export function getDefaultAbandonedTab(
+  abandoned: AbandonedCartsResult
+): "buy_now" | "reorder" {
+  if (abandoned.buyNowCarts.length > 0) {
+    return "buy_now"
+  }
+
+  return "reorder"
+}
+
+export function getCartTotalItemCount(cart: HttpTypes.StoreCart): number {
+  return cart.items?.reduce((total, item) => total + item.quantity, 0) ?? 0
+}
+
+export function getAbandonedTotalItemCount(carts: HttpTypes.StoreCart[]): number {
+  return carts.reduce((total, cart) => total + getCartTotalItemCount(cart), 0)
+}

package/src/domain/cart/buy-now.ts

@@ -0,0 +1,15 @@
+export function getBuyNowCheckoutUrl(
+  countryCode: string,
+  cartId: string,
+  skipToPayment: boolean
+): string {
+  if (skipToPayment) {
+    return `/${countryCode}/checkout?step=payment&cart_id=${cartId}`
+  }
+
+  return `/${countryCode}/checkout?cart_id=${cartId}`
+}
+
+export function shouldSkipToPayment(shippingOptionsCount: number): boolean {
+  return shippingOptionsCount > 0
+}

package/src/domain/cart/checkout.ts

@@ -0,0 +1,25 @@
+export function isCheckoutPath(pathname: string): boolean {
+  return pathname.includes("/checkout")
+}
+
+export function shouldCheckEphemeralCartMetadata(options: {
+  explicitCartId?: string
+  pathname: string
+}): boolean {
+  return !options.explicitCartId && !isCheckoutPath(options.pathname)
+}
+
+export type PostOrderCookieAction = "remove_buy_now" | "remove_main_cart"
+
+export function getPostOrderCookieAction(
+  hasBuyNowCookie: boolean
+): PostOrderCookieAction {
+  return hasBuyNowCookie ? "remove_buy_now" : "remove_main_cart"
+}
+
+export function getResumeAbandonedCheckoutUrl(
+  countryCode: string,
+  cartId: string
+): string {
+  return `/${countryCode}/checkout?cart_id=${cartId}`
+}

package/src/domain/cart/index.ts

@@ -0,0 +1,8 @@
+export * from "./metadata"
+export * from "./abandoned-carts"
+export * from "./buy-now"
+export * from "./reorder"
+export * from "./checkout"
+export * from "./validation"
+export * from "./phone"
+export * from "./payment"

package/src/domain/cart/metadata.ts

@@ -0,0 +1,21 @@
+export type CartMetadata = Record<string, unknown>
+
+export function isBuyNowCart(metadata?: CartMetadata | null): boolean {
+  return metadata?.is_buy_now === true
+}
+
+export function isReorderCart(metadata?: CartMetadata | null): boolean {
+  return metadata?.is_reorder === true
+}
+
+export function isEphemeralCart(metadata?: CartMetadata | null): boolean {
+  return isBuyNowCart(metadata) || isReorderCart(metadata)
+}
+
+export function createBuyNowMetadata(): CartMetadata {
+  return { is_buy_now: true }
+}
+
+export function createReorderMetadata(): CartMetadata {
+  return { is_reorder: true }
+}

package/src/domain/cart/payment.ts

@@ -0,0 +1,21 @@
+export function requiresRazorpayContact(providerId: string): boolean {
+  return providerId.includes("razorpay")
+}
+
+export function validateRazorpayPreflight(options: {
+  providerId: string
+  phone?: string
+  email?: string
+}): void {
+  if (requiresRazorpayContact(options.providerId) && !options.phone) {
+    throw new Error(
+      "CRITICAL Error: Phone number is missing from your address. Razorpay requires a contact number for verification. Please enter your phone number."
+    )
+  }
+
+  if (requiresRazorpayContact(options.providerId) && !options.email) {
+    throw new Error(
+      "CRITICAL Error: Email is missing from your cart. Razorpay requires an email address. Please enter your email."
+    )
+  }
+}

package/src/domain/cart/phone.ts

@@ -0,0 +1,17 @@
+export function normalizePhoneForRazorpay(phone?: string): string | undefined {
+  if (!phone) {
+    return undefined
+  }
+
+  const cleaned = String(phone).replace(/\D/g, "")
+
+  if (cleaned.length === 10) {
+    return `+91${cleaned}`
+  }
+
+  if (cleaned.length > 10 && !String(phone).startsWith("+")) {
+    return `+${cleaned}`
+  }
+
+  return phone
+}

package/src/domain/cart/reorder.ts

@@ -0,0 +1,19 @@
+import { createReorderMetadata } from "./metadata"
+
+export function extractNewCartIdFromReorderResponse(
+  data: Record<string, unknown>
+): string | undefined {
+  const cart = data.cart as { id?: string } | undefined
+  const reorder = data.reorder as { cart_id?: string } | undefined
+
+  return (
+    cart?.id ||
+    (data.id as string | undefined) ||
+    (data.cart_id as string | undefined) ||
+    reorder?.cart_id
+  )
+}
+
+export function buildReorderCartMetadata() {
+  return createReorderMetadata()
+}