@pradip1995/commerce-core 1.0.0

package/src/data/cart/mutations.ts

@@ -0,0 +1,189 @@
+"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 { getOrSetCart } from "./retrieve"
+
+export async function updateCart(data: HttpTypes.StoreUpdateCart) {
+  const cartId = await getCartId()
+
+  if (!cartId) {
+    throw new Error("No existing cart found, please create one before updating")
+  }
+
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  return sdk.store.cart
+    .update(cartId, data, {}, headers)
+    .then(async ({ cart }: { cart: HttpTypes.StoreCart }) => {
+      const cartCacheTag = await getCacheTag("carts")
+      revalidateTag(cartCacheTag)
+
+      const fulfillmentCacheTag = await getCacheTag("fulfillment")
+      revalidateTag(fulfillmentCacheTag)
+
+      return cart
+    })
+    .catch(medusaError)
+}
+
+export async function addToCart({
+  variantId,
+  quantity,
+  countryCode,
+}: {
+  variantId: string
+  quantity: number
+  countryCode: string
+}) {
+  validateAddToCartInput({ variantId, quantity })
+
+  const cart = await getOrSetCart(countryCode)
+
+  if (!cart) {
+    throw new Error("Error retrieving or creating cart")
+  }
+
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  await sdk.store.cart
+    .createLineItem(
+      cart.id,
+      {
+        variant_id: variantId,
+        quantity,
+      },
+      {},
+      headers
+    )
+    .then(async () => {
+      const cartCacheTag = await getCacheTag("carts")
+      revalidateTag(cartCacheTag)
+
+      const fulfillmentCacheTag = await getCacheTag("fulfillment")
+      revalidateTag(fulfillmentCacheTag)
+    })
+    .catch(medusaError)
+}
+
+export async function updateLineItem({
+  lineId,
+  quantity,
+}: {
+  lineId: string
+  quantity: number
+}) {
+  validateLineItemUpdateInput({ lineId, quantity })
+
+  const cartId = await getCartId()
+  validateCartId(cartId)
+
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  await sdk.store.cart
+    .updateLineItem(cartId!, lineId, { quantity }, {}, headers)
+    .then(async () => {
+      const cartCacheTag = await getCacheTag("carts")
+      revalidateTag(cartCacheTag)
+
+      const fulfillmentCacheTag = await getCacheTag("fulfillment")
+      revalidateTag(fulfillmentCacheTag)
+    })
+    .catch(medusaError)
+}
+
+export async function deleteLineItem(lineId: string) {
+  validateLineItemDeleteInput(lineId)
+
+  const cartId = await getCartId()
+  validateCartId(cartId)
+
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  await sdk.store.cart
+    .deleteLineItem(cartId!, lineId, {}, headers)
+    .then(async () => {
+      const cartCacheTag = await getCacheTag("carts")
+      revalidateTag(cartCacheTag)
+
+      const fulfillmentCacheTag = await getCacheTag("fulfillment")
+      revalidateTag(fulfillmentCacheTag)
+    })
+    .catch(medusaError)
+}
+
+export async function updateLineItemVariant({
+  lineId,
+  variantId,
+  quantity,
+  countryCode,
+}: {
+  lineId: string
+  variantId: string
+  quantity: number
+  countryCode: string
+}) {
+  if (!lineId) {
+    throw new Error("Missing lineItem ID when updating variant")
+  }
+
+  if (!variantId) {
+    throw new Error("Missing variant ID when updating variant")
+  }
+
+  // Delete the old line item
+  await deleteLineItem(lineId)
+
+  // Add new line item with the new variant
+  await addToCart({
+    variantId,
+    quantity,
+    countryCode,
+  })
+}

package/src/data/cart/promotions.ts

@@ -0,0 +1,121 @@
+"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 applyPromotions(codes: string[]) {
+  const cartId = await getCartId()
+
+  if (!cartId) {
+    throw new Error("No existing cart found")
+  }
+
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  return sdk.store.cart
+    .update(cartId, { promo_codes: codes }, {}, headers)
+    .then(async ({ cart }) => {
+      const cartCacheTag = await getCacheTag("carts")
+      revalidateTag(cartCacheTag)
+
+      const fulfillmentCacheTag = await getCacheTag("fulfillment")
+      revalidateTag(fulfillmentCacheTag)
+
+      return cart
+    })
+    .catch(medusaError)
+}
+
+export async function applyGiftCard(code: string) {
+  //   const cartId = getCartId()
+  //   if (!cartId) return "No cartId cookie found"
+  //   try {
+  //     await updateCart(cartId, { gift_cards: [{ code }] }).then(() => {
+  //       revalidateTag("cart")
+  //     })
+  //   } catch (error: any) {
+  //     throw error
+  //   }
+}
+
+export async function removeDiscount(code: string) {
+  // const cartId = getCartId()
+  // if (!cartId) return "No cartId cookie found"
+  // try {
+  //   await deleteDiscount(cartId, code)
+  //   revalidateTag("cart")
+  // } catch (error: any) {
+  //   throw error
+  // }
+}
+
+export async function removeGiftCard(
+  codeToRemove: string,
+  giftCards: any[]
+  // giftCards: GiftCard[]
+) {
+  //   const cartId = getCartId()
+  //   if (!cartId) return "No cartId cookie found"
+  //   try {
+  //     await updateCart(cartId, {
+  //       gift_cards: [...giftCards]
+  //         .filter((gc) => gc.code !== codeToRemove)
+  //         .map((gc) => ({ code: gc.code })),
+  //     }).then(() => {
+  //       revalidateTag("cart")
+  //     })
+  //   } catch (error: any) {
+  //     throw error
+  //   }
+}
+
+export async function submitPromotionForm(currentState: unknown, formData: FormData) {
+  const code = formData.get("code") as string
+  try {
+    await applyPromotions([code])
+  } catch (e: any) {
+    return e.message
+  }
+}
+
+// TODO: Pass a POJO instead of a form entity here

package/src/data/cart/region.ts

@@ -0,0 +1,66 @@
+"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 { updateCart } from "./mutations"
+
+export async function updateRegion(countryCode: string, currentPath: string) {
+  const cartId = await getCartId()
+  const region = await getRegion(countryCode)
+
+  if (!region) {
+    throw new Error(`Region not found for country code: ${countryCode}`)
+  }
+
+  if (cartId) {
+    await updateCart({ region_id: region.id })
+    const cartCacheTag = await getCacheTag("carts")
+    revalidateTag(cartCacheTag)
+  }
+
+  const regionCacheTag = await getCacheTag("regions")
+  revalidateTag(regionCacheTag)
+
+  const productsCacheTag = await getCacheTag("products")
+  revalidateTag(productsCacheTag)
+
+  redirect(`/${countryCode}${currentPath}`)
+}

package/src/data/cart/retrieve.ts

@@ -0,0 +1,162 @@
+"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 const retrieveCart = cache(async (cartId?: string, fields?: string) => {
+  let id = cartId || (await getCartId())
+  const heldId = await getHoldCartId()
+
+  // AUTO-RESTORE LOGIC:
+  // If we're not explicitly asking for a specific cartId and we have an active cart
+  if (!cartId && id) {
+    try {
+      const headerList = await getRequestHeaders()
+      const pathname = headerList.get("x-pathname") || headerList.get("referer") || ""
+
+      if (shouldCheckEphemeralCartMetadata({ explicitCartId: cartId, pathname })) {
+        const currentCart = await sdk.client
+          .fetch<HttpTypes.StoreCartResponse>(`/store/carts/${id}`, {
+            method: "GET",
+            query: { fields: "metadata" },
+            headers: await getAuthHeaders(),
+            cache: "no-store",
+          })
+          .then(({ cart }) => cart)
+          .catch(() => null)
+
+        if (isEphemeralCart(currentCart?.metadata)) {
+          await removeBuyNowCartId()
+          id = await getCartId() // Re-fetch ID which will now fall back to the real main cart
+          revalidateTag("carts")
+        }
+      }
+    } catch (e) {
+      // Silent fail
+    }
+  }
+
+  fields ??=
+    "*items, *region, *items.product, *items.product.thumbnail, *items.product.images, *items.product.options, *items.product.variants, +items.product.variants.inventory_quantity, +items.product.variants.manage_inventory, +items.product.variants.allow_backorder, *items.product.variants.options, *items.variant, +items.variant.inventory_quantity, +items.variant.manage_inventory, +items.variant.allow_backorder, *items.variant.images, *items.variant.product, *items.variant.product.thumbnail, *items.variant.product.images, *items.variant.options, *items.thumbnail, *items.metadata, +items.total, +items.adjustments, *promotions, +shipping_methods.name, +shipping_methods.adjustments"
+
+  if (!id) {
+    return null
+  }
+
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  const next = {
+    ...(await getCacheOptions("carts")),
+  }
+
+  return await sdk.client
+    .fetch<HttpTypes.StoreCartResponse>(`/store/carts/${id}`, {
+      method: "GET",
+      query: {
+        fields,
+      },
+      headers,
+      next,
+      cache: "no-store",
+    })
+    .then(({ cart }: { cart: HttpTypes.StoreCart }) => {
+      return cart
+    })
+    .catch(() => null)
+})
+
+export async function getOrSetCart(countryCode: string) {
+  const region = await getRegion(countryCode)
+
+  if (!region) {
+    throw new Error(`Region not found for country code: ${countryCode}`)
+  }
+
+  let cart = await retrieveCart(undefined, "id,region_id")
+
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  if (!cart) {
+    const locale = await getLocale()
+    const cartResp = await sdk.store.cart.create(
+      { region_id: region.id, locale: locale || undefined },
+      {},
+      headers
+    )
+    cart = cartResp.cart
+
+    await setCartId(cart.id)
+
+    const cartCacheTag = await getCacheTag("carts")
+    revalidateTag(cartCacheTag)
+  }
+
+  if (cart && cart?.region_id !== region.id) {
+    await sdk.store.cart.update(cart.id, { region_id: region.id }, {}, headers)
+    const cartCacheTag = await getCacheTag("carts")
+    revalidateTag(cartCacheTag)
+  }
+
+  return cart
+}
+
+export async function listCartOptions() {
+  const cartId = await getCartId()
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+  const next = {
+    ...(await getCacheOptions("shippingOptions")),
+  }
+
+  return await sdk.client.fetch<{
+    shipping_options: HttpTypes.StoreCartShippingOption[]
+  }>("/store/shipping-options", {
+    query: { cart_id: cartId },
+    next,
+    headers,
+    cache: "force-cache",
+  })
+}

package/src/data/categories.ts

@@ -0,0 +1,90 @@
+import { sdk } from "@core/config"
+import { HttpTypes } from "@medusajs/types"
+import { getCacheOptions } from "./cookies"
+
+export const listCategories = async (query?: Record<string, any>) => {
+  try {
+    const next = {
+      ...(await getCacheOptions("categories")),
+    }
+
+    const limit = query?.limit || 100
+
+    return sdk.client
+      .fetch<{ product_categories: HttpTypes.StoreProductCategory[] }>(
+        "/store/product-categories",
+        {
+          query: {
+            fields:
+              "*category_children, *products, *parent_category, *parent_category.parent_category",
+            limit,
+            ...query,
+          },
+          next: {
+            ...next,
+            revalidate: 0,
+          },
+          cache: "no-store",
+        }
+      )
+      .then(({ product_categories }) => product_categories)
+      .catch((error) => {
+        if (process.env.NODE_ENV === "production" || process.env.CI) {
+          return []
+        }
+        throw error
+      })
+  } catch (error: any) {
+    if (process.env.NODE_ENV === "production" || process.env.CI) {
+      return []
+    }
+    throw error
+  }
+}
+
+export const getCategoryByHandle = async (categoryHandle: string[]) => {
+  try {
+    const handle = `${categoryHandle.join("/")}`
+    const decodedHandle = decodeURIComponent(handle)
+
+    const next = {
+      ...(await getCacheOptions("categories")),
+    }
+
+    const result = await sdk.client.fetch<HttpTypes.StoreProductCategoryListResponse>(
+      `/store/product-categories`,
+      {
+        query: {
+          handle: [decodedHandle],
+        },
+        next: {
+          ...next,
+          revalidate: 0,
+        },
+        cache: "no-store",
+      }
+    )
+
+    if (result.product_categories && result.product_categories.length > 0) {
+      return result.product_categories[0]
+    }
+
+    // Fallback: Fetch all categories and find manually
+
+    const allCategories = await listCategories({ limit: "200" })
+    const matchedCategory = allCategories.find(
+      (c) =>
+        c.handle === decodedHandle ||
+        c.handle === handle ||
+        c.handle?.replace(/-/g, " ") === decodedHandle
+    )
+
+    if (matchedCategory) {
+      return matchedCategory
+    }
+
+    return null
+  } catch (error: any) {
+    return null
+  }
+}