@pradip1995/commerce-core 1.0.0

package/src/data/cart/buyNow.ts

@@ -0,0 +1,184 @@
+"use server"
+
+import { sdk } from "@core/config"
+import medusaError from "@core/util/medusa-error"
+import { HttpTypes } from "@medusajs/types"
+import { revalidateTag, revalidatePath } from "next/cache"
+import { redirect } from "next/navigation"
+import { headers as getRequestHeaders } from "next/headers"
+import {
+  getAuthHeaders,
+  getCacheOptions,
+  getCacheTag,
+  getCartId,
+  removeCartId,
+  setCartId,
+  getHoldCartId,
+  setHoldCartId,
+  removeHoldCartId,
+  setBuyNowCartId,
+  removeBuyNowCartId,
+} from "../cookies"
+import { getRegion } from "../regions"
+import { getLocale } from "@core/data/locale-actions"
+import { retrieveCustomer, transferCart } from "@core/data/customer"
+import { cache } from "react"
+import {
+  createBuyNowMetadata,
+  filterOutCurrentCart,
+  getBuyNowCheckoutUrl,
+  getPostOrderCookieAction,
+  getResumeAbandonedCheckoutUrl,
+  isEphemeralCart,
+  normalizePhoneForRazorpay,
+  partitionAbandonedCarts,
+  shouldCheckEphemeralCartMetadata,
+  shouldSkipToPayment,
+  validateAddToCartInput,
+  validateCartId,
+  validateLineItemDeleteInput,
+  validateLineItemUpdateInput,
+  validateRazorpayPreflight,
+} from "@core/domain/cart"
+
+export async function buyNow({
+  variantId,
+  quantity,
+  countryCode,
+}: {
+  variantId: string
+  quantity: number
+  countryCode: string
+}) {
+  validateAddToCartInput({ variantId, quantity })
+
+  const region = await getRegion(countryCode)
+
+  if (!region) {
+    throw new Error(`Region not found for country code: ${countryCode}`)
+  }
+
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  const locale = await getLocale()
+
+  // 1. Create a NEW cart regardless of existing one
+  const cartResp = await sdk.store.cart.create(
+    {
+      region_id: region.id,
+      locale: locale || undefined,
+      metadata: createBuyNowMetadata(),
+    },
+    {},
+    headers
+  )
+  const cart = cartResp.cart
+
+  // Save the new cart id in "buy_now_cart_id" cookie
+  await removeBuyNowCartId()
+  await setBuyNowCartId(cart.id)
+
+  // Ensure this new cart is not merged with existing ones
+  try {
+    await sdk.client.fetch(`/store/carts/merge/skip`, {
+      method: "POST",
+      body: { cart_id: cart.id },
+      headers,
+    })
+  } catch (e) {
+    console.error("Failed to skip cart merge for buy now cart:", e)
+  }
+
+  // 2. Add the item to this new cart
+  await sdk.store.cart.createLineItem(
+    cart.id,
+    {
+      variant_id: variantId,
+      quantity,
+    },
+    {},
+    headers
+  )
+
+  // 3. (REMOVED: No longer overwriting the main cart ID, because getCartId handles buy_now_cart_id priority)
+
+  // 4. OPTIMIZATION: If user is logged in and has addresses, auto-fill and skip to payment
+  const customer = await retrieveCustomer().catch(() => null)
+  const defaultAddress =
+    customer?.addresses?.find(
+      (a) =>
+        a.is_default_shipping ||
+        a.metadata?.is_default === "true" ||
+        a.metadata?.is_default === true
+    ) || customer?.addresses?.[0]
+
+  let skipToPayment = false
+
+  if (defaultAddress) {
+    try {
+      // Set addresses
+      await sdk.store.cart.update(
+        cart.id,
+        {
+          shipping_address: {
+            first_name: defaultAddress.first_name,
+            last_name: defaultAddress.last_name,
+            address_1: defaultAddress.address_1,
+            address_2: defaultAddress.address_2,
+            city: defaultAddress.city,
+            country_code: defaultAddress.country_code,
+            postal_code: defaultAddress.postal_code,
+            province: defaultAddress.province,
+            phone: defaultAddress.phone,
+            company: defaultAddress.company,
+          },
+          billing_address: {
+            first_name: defaultAddress.first_name,
+            last_name: defaultAddress.last_name,
+            address_1: defaultAddress.address_1,
+            address_2: defaultAddress.address_2,
+            city: defaultAddress.city,
+            country_code: defaultAddress.country_code,
+            postal_code: defaultAddress.postal_code,
+            province: defaultAddress.province,
+            phone: defaultAddress.phone,
+            company: defaultAddress.company,
+          },
+          email: customer?.email,
+        },
+        {},
+        headers
+      )
+
+      // Fetch and set first shipping method
+      const { shipping_options } = await sdk.client.fetch<{
+        shipping_options: HttpTypes.StoreCartShippingOption[]
+      }>("/store/shipping-options", {
+        query: { cart_id: cart.id },
+        headers,
+        cache: "no-store",
+      })
+
+      if (shouldSkipToPayment(shipping_options?.length ?? 0)) {
+        await sdk.store.cart.addShippingMethod(
+          cart.id,
+          { option_id: shipping_options[0].id },
+          {},
+          headers
+        )
+        skipToPayment = true
+      }
+    } catch (e) {
+      // Fallback to normal checkout if anything fails
+      console.error("Failed to auto-fill address and shipping:", e)
+    }
+  }
+
+  const cartCacheTag = await getCacheTag("carts")
+  revalidateTag(cartCacheTag)
+  revalidatePath(`/${countryCode}/checkout`, "page")
+
+  redirect(getBuyNowCheckoutUrl(countryCode, cart.id, skipToPayment))
+}

package/src/data/cart/checkout.ts

@@ -0,0 +1,487 @@
+"use server"
+
+import { sdk } from "@core/config"
+import medusaError from "@core/util/medusa-error"
+import { HttpTypes } from "@medusajs/types"
+import { revalidateTag, revalidatePath } from "next/cache"
+import { redirect } from "next/navigation"
+import { headers as getRequestHeaders } from "next/headers"
+import {
+  getAuthHeaders,
+  getCacheOptions,
+  getCacheTag,
+  getCartId,
+  removeCartId,
+  setCartId,
+  getHoldCartId,
+  setHoldCartId,
+  removeHoldCartId,
+  setBuyNowCartId,
+  removeBuyNowCartId,
+} from "../cookies"
+import { getRegion } from "../regions"
+import { getLocale } from "@core/data/locale-actions"
+import { retrieveCustomer, transferCart } from "@core/data/customer"
+import { cache } from "react"
+import {
+  createBuyNowMetadata,
+  filterOutCurrentCart,
+  getBuyNowCheckoutUrl,
+  getPostOrderCookieAction,
+  getResumeAbandonedCheckoutUrl,
+  isEphemeralCart,
+  normalizePhoneForRazorpay,
+  partitionAbandonedCarts,
+  shouldCheckEphemeralCartMetadata,
+  shouldSkipToPayment,
+  validateAddToCartInput,
+  validateCartId,
+  validateLineItemDeleteInput,
+  validateLineItemUpdateInput,
+  validateRazorpayPreflight,
+} from "@core/domain/cart"
+import { retrieveCart } from "./retrieve"
+import { updateCart } from "./mutations"
+
+export async function setShippingMethod({
+  cartId,
+  shippingMethodId,
+}: {
+  cartId: string
+  shippingMethodId: string
+}) {
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  return sdk.store.cart
+    .addShippingMethod(cartId, { option_id: shippingMethodId }, {}, headers)
+    .then(async () => {
+      const cartCacheTag = await getCacheTag("carts")
+      revalidateTag(cartCacheTag)
+    })
+    .catch(medusaError)
+}
+
+/**
+ * Sets a shipping method silently without triggering a full page revalidation.
+ */
+
+export async function setShippingMethodSilently({
+  cartId,
+  shippingMethodId,
+}: {
+  cartId: string
+  shippingMethodId: string
+}) {
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  try {
+    await sdk.store.cart.addShippingMethod(
+      cartId,
+      { option_id: shippingMethodId },
+      {},
+      headers
+    )
+    return { success: true }
+  } catch (e) {
+    return { success: false }
+  }
+}
+
+export async function initiatePaymentSession(
+  cart: HttpTypes.StoreCart,
+  data: HttpTypes.StoreInitializePaymentSession
+) {
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  // 1. RE-FETCH cart with NO CACHE to ensure we have the latest data from the DB
+  const latestCart = await retrieveCart(cart.id)
+  if (!latestCart) throw new Error("Cart not found")
+
+  const rawPhone =
+    latestCart.shipping_address?.phone || latestCart.billing_address?.phone
+  const phone = normalizePhoneForRazorpay(rawPhone)
+
+  // 2. Critical Fix for Razorpay: Ensure normalized phone is in BOTH shipping and billing addresses
+  if (phone) {
+    const addressUpdates: any = {}
+
+    // Clean address helper to ensure we pass a clean object to the update API
+    const cleanAddress = (addr: any) => {
+      if (!addr) return null
+      return {
+        first_name: addr.first_name,
+        last_name: addr.last_name,
+        address_1: addr.address_1,
+        address_2: addr.address_2 || "",
+        city: addr.city,
+        country_code: addr.country_code,
+        postal_code: addr.postal_code,
+        province: addr.province,
+        company: addr.company,
+        phone: phone,
+      }
+    }
+
+    // Update if phone is missing in DB
+    if (latestCart.shipping_address && !latestCart.shipping_address.phone) {
+      addressUpdates.shipping_address = cleanAddress(latestCart.shipping_address)
+    }
+
+    if (latestCart.billing_address && !latestCart.billing_address.phone) {
+      addressUpdates.billing_address =
+        cleanAddress(latestCart.billing_address) ||
+        cleanAddress(latestCart.shipping_address)
+    }
+
+    if (Object.keys(addressUpdates).length > 0) {
+      await sdk.store.cart.update(latestCart.id, addressUpdates, {}, headers)
+    }
+  }
+
+  // 3. Final re-fetch (direct SDK call to bypass any lib-level cache)
+  const cartResponse = await sdk.store.cart.retrieve(
+    cart.id,
+    { fields: "*shipping_address,*billing_address" },
+    headers
+  )
+  const finalCart = cartResponse.cart
+
+  const displayPhone =
+    finalCart.shipping_address?.phone || finalCart.billing_address?.phone || phone
+
+  validateRazorpayPreflight({
+    providerId: data.provider_id,
+    phone: displayPhone,
+    email: finalCart.email,
+  })
+
+  // 5. ENHANCED DATA FOR RAZORPAY:
+  const enhancedData = {
+    ...data,
+    data: {
+      ...(data.data || {}),
+      billing_address: finalCart.billing_address || finalCart.shipping_address,
+      customer: {
+        email: finalCart.email,
+        phone: displayPhone,
+        first_name:
+          finalCart.billing_address?.first_name ||
+          finalCart.shipping_address?.first_name,
+        last_name:
+          finalCart.billing_address?.last_name || finalCart.shipping_address?.last_name,
+      },
+    },
+  }
+
+  return sdk.store.payment
+    .initiatePaymentSession(finalCart, enhancedData, {}, headers)
+    .then(async (resp) => {
+      const cartCacheTag = await getCacheTag("carts")
+      revalidateTag(cartCacheTag)
+      return resp
+    })
+    .catch((e) => {
+      const errorMsg = e.message || e.response?.data?.message || "Unknown error"
+      throw new Error(`Razorpay Initialization Failed: ${errorMsg}`)
+    })
+}
+
+export async function setAddresses(currentState: unknown, formData: FormData) {
+  try {
+    if (!formData) {
+      throw new Error("No form data found when setting addresses")
+    }
+    const cartId = await getCartId()
+    if (!cartId) {
+      throw new Error("No existing cart found when setting addresses")
+    }
+
+    const shippingCountryCode =
+      (formData.get("shipping_address.country_code") as string)?.toLowerCase() || "in"
+
+    const rawPhone = formData.get("shipping_address.phone") as string
+    const phone = normalizePhoneForRazorpay(rawPhone)
+
+    const shippingAddress = {
+      first_name: formData.get("shipping_address.first_name") as string,
+      last_name: formData.get("shipping_address.last_name") as string,
+      address_1: formData.get("shipping_address.address_1") as string,
+      address_2: (formData.get("shipping_address.address_2") as string) || "",
+      company: formData.get("shipping_address.company") as string,
+      postal_code: formData.get("shipping_address.postal_code") as string,
+      city: formData.get("shipping_address.city") as string,
+      country_code: shippingCountryCode,
+      province: formData.get("shipping_address.province") as string,
+      phone: phone as string,
+    }
+
+    const data = {
+      shipping_address: shippingAddress,
+      email: formData.get("email"),
+    } as any
+
+    // Save address to customer profile if logged in
+    const authHeaders = await getAuthHeaders()
+    if (authHeaders && "authorization" in authHeaders) {
+      try {
+        // Fetch current customer to check if address already exists
+        const { customer } = await sdk.client.fetch<{
+          customer: HttpTypes.StoreCustomer
+        }>(`/store/customers/me`, {
+          method: "GET",
+          query: { fields: "*addresses" },
+          headers: authHeaders as Record<string, string>,
+          cache: "no-store",
+        })
+
+        const addressExists = customer?.addresses?.some(
+          (a: any) =>
+            a.address_1 === shippingAddress.address_1 &&
+            a.postal_code === shippingAddress.postal_code &&
+            a.city === shippingAddress.city &&
+            a.first_name === shippingAddress.first_name &&
+            a.last_name === shippingAddress.last_name
+        )
+
+        if (!addressExists) {
+          await sdk.store.customer.createAddress(
+            shippingAddress,
+            {},
+            authHeaders as Record<string, string>
+          )
+          const customerCacheTag = await getCacheTag("customers")
+          revalidateTag(customerCacheTag)
+        }
+      } catch (e) {
+        // Silently fail when saving address to customer profile
+      }
+    }
+
+    const sameAsBilling = formData.get("same_as_billing")
+    if (sameAsBilling === "on") {
+      data.billing_address = { ...data.shipping_address }
+    }
+
+    if (sameAsBilling !== "on") {
+      const bPhone =
+        normalizePhoneForRazorpay(formData.get("billing_address.phone") as string) ||
+        phone
+      data.billing_address = {
+        first_name: formData.get("billing_address.first_name"),
+        last_name: formData.get("billing_address.last_name"),
+        address_1: formData.get("billing_address.address_1"),
+        address_2: formData.get("billing_address.address_2") || "",
+        company: formData.get("billing_address.company"),
+        postal_code: formData.get("billing_address.postal_code"),
+        city: formData.get("billing_address.city"),
+        country_code: shippingCountryCode,
+        province: formData.get("billing_address.province"),
+        phone: bPhone,
+      }
+    }
+    await updateCart(data)
+  } catch (e: any) {
+    return e.message
+  }
+
+  revalidateTag("carts")
+}
+
+/**
+ * Places an order for a cart. If no cart ID is provided, it will use the cart ID from the cookies.
+ * @param cartId - optional - The ID of the cart to place an order for.
+ * @returns The cart object if the order was successful, or null if not.
+ */
+
+export async function placeOrder(cartId?: string) {
+  const id = cartId || (await getCartId())
+
+  if (!id) {
+    throw new Error("No existing cart found when placing an order")
+  }
+
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  const cartRes = await sdk.store.cart
+    .complete(id, {}, headers)
+    .then(async (cartRes) => {
+      const cartCacheTag = await getCacheTag("carts")
+      revalidateTag(cartCacheTag)
+      return cartRes
+    })
+    .catch(medusaError)
+
+  if (cartRes?.type === "order") {
+    const countryCode = cartRes.order.shipping_address?.country_code?.toLowerCase()
+
+    const orderCacheTag = await getCacheTag("orders")
+    revalidateTag(orderCacheTag)
+
+    // NEW LOGIC: Check if we just completed a Buy Now cart
+    const { cookies: nextCookies } = await import("next/headers")
+    const cookiesStore = await nextCookies()
+    const buyNowId = cookiesStore.get("buy_now_cart_id")?.value
+
+    const cookieAction = getPostOrderCookieAction(!!buyNowId)
+
+    if (cookieAction === "remove_buy_now") {
+      await removeBuyNowCartId()
+    } else {
+      await removeCartId()
+    }
+
+    redirect(`/${countryCode}/order/${cartRes?.order.id}/confirmed`)
+  }
+
+  return cartRes.cart
+}
+
+/**
+ * Updates the countrycode param and revalidates the regions cache
+ * @param regionId
+ * @param countryCode
+ */
+
+export async function addCustomerAddressToCart(
+  currentState: unknown,
+  formData: FormData
+) {
+  try {
+    const headers = {
+      ...(await getAuthHeaders()),
+    }
+
+    const shippingCountryCode =
+      (formData.get("shipping_address.country_code") as string)?.toLowerCase() || "in"
+
+    // Parse address data from formData (which uses shipping_address. prefix)
+    const addressData = {
+      first_name: formData.get("shipping_address.first_name") as string,
+      last_name: formData.get("shipping_address.last_name") as string,
+      company: formData.get("shipping_address.company") as string,
+      address_1: formData.get("shipping_address.address_1") as string,
+      address_2: formData.get("shipping_address.address_2") as string,
+      city: formData.get("shipping_address.city") as string,
+      postal_code: formData.get("shipping_address.postal_code") as string,
+      province: formData.get("shipping_address.province") as string,
+      country_code: shippingCountryCode,
+      phone: formData.get("shipping_address.phone") as string,
+      metadata: {
+        is_default: formData.get("is_default") === "true",
+        address_type: formData.get("address_type"),
+      },
+    }
+
+    const addressId = formData.get("address_id") as string
+
+    // 1. Add/Update Customer Address Book
+    // We try/catch this separately so if it fails (e.g. user not logged in), we still try to proceed with checkout
+    try {
+      if (addressId) {
+        await sdk.store.customer.updateAddress(addressId, addressData, {}, headers)
+      } else {
+        await sdk.store.customer.createAddress(addressData, {}, headers)
+      }
+      const customerCacheTag = await getCacheTag("customers")
+      revalidateTag(customerCacheTag)
+    } catch (e) {
+      // verify if it is an auth error, maybe we shouldn't fail silently?
+      // But for checkout flow, the priority is to proceed.
+    }
+
+    // 2. Set as Cart Shipping Address
+    const cartId = await getCartId()
+    if (!cartId) {
+      throw new Error("No existing cart found when setting addresses")
+    }
+
+    const cartData = {
+      shipping_address: {
+        first_name: addressData.first_name,
+        last_name: addressData.last_name,
+        company: addressData.company,
+        address_1: addressData.address_1,
+        address_2: addressData.address_2,
+        city: addressData.city,
+        postal_code: addressData.postal_code,
+        province: addressData.province,
+        country_code: addressData.country_code,
+        phone: addressData.phone,
+      },
+      email: formData.get("email"),
+    } as any
+
+    const sameAsBilling = formData.get("same_as_billing")
+    if (sameAsBilling === "on") {
+      cartData.billing_address = cartData.shipping_address
+    } else {
+      // If not same as billing, we should ideally handle billing address too,
+      // but AddAddressModal usually forces same_as_billing="on" (Line 52 in AddAddressModal).
+      // If we ever change that, we'll need logic here. For now, AddAddressModal is strictly for "Add New Shippping Address".
+    }
+
+    await updateCart(cartData)
+  } catch (e: any) {
+    return e.message
+  }
+
+  revalidateTag("carts")
+  // No redirect if we are already in checkout to prevent disrupting the user
+}
+
+/**
+ * Updates address in the background without redirecting.
+ * Used for real-time shipping calculation when pincode is entered.
+ */
+
+export async function updateAddressSilently(data: any) {
+  const cartId = await getCartId()
+  if (!cartId) return
+
+  try {
+    const headers = {
+      ...(await getAuthHeaders()),
+    }
+
+    await sdk.store.cart.update(cartId, data, {}, headers)
+
+    // Revalidate tags to ensure CartTotals gets new shipping info
+    const cartCacheTag = await getCacheTag("carts")
+    revalidateTag(cartCacheTag)
+
+    const fulfillmentCacheTag = await getCacheTag("fulfillment")
+    revalidateTag(fulfillmentCacheTag)
+
+    return { success: true }
+  } catch (e) {
+    return { success: false }
+  }
+}
+/**
+ * Updates cart metadata silently without triggering a full page revalidation.
+ */
+
+export async function updateCartMetadataSilently(metadata: any) {
+  const cartId = await getCartId()
+  if (!cartId) return
+
+  try {
+    const headers = {
+      ...(await getAuthHeaders()),
+    }
+
+    await sdk.store.cart.update(cartId, { metadata }, {}, headers)
+    // We intentionally DO NOT call revalidateTag here to prevent page refresh loops
+    return { success: true }
+  } catch (e) {
+    return { success: false }
+  }
+}

package/src/data/cart/index.ts

@@ -0,0 +1,7 @@
+export * from "./retrieve"
+export * from "./mutations"
+export * from "./buyNow"
+export * from "./checkout"
+export * from "./promotions"
+export * from "./abandoned"
+export * from "./region"