@pradip1995/commerce-core 1.0.0

package/src/domain/cart/validation.ts

@@ -0,0 +1,43 @@
+export function validateVariantId(variantId?: string): void {
+  if (!variantId) {
+    throw new Error("Missing variant ID when adding to cart")
+  }
+}
+
+export function validateLineId(lineId?: string): void {
+  if (!lineId) {
+    throw new Error("Missing lineItem ID when updating line item")
+  }
+}
+
+export function validateCartId(cartId?: string | null): void {
+  if (!cartId) {
+    throw new Error("Missing cart ID when updating line item")
+  }
+}
+
+export function validateQuantity(quantity: number): void {
+  if (quantity < 1) {
+    throw new Error("Quantity must be at least 1")
+  }
+}
+
+export function validateAddToCartInput(input: {
+  variantId: string
+  quantity: number
+}): void {
+  validateVariantId(input.variantId)
+  validateQuantity(input.quantity)
+}
+
+export function validateLineItemUpdateInput(input: {
+  lineId: string
+  quantity: number
+}): void {
+  validateLineId(input.lineId)
+  validateQuantity(input.quantity)
+}
+
+export function validateLineItemDeleteInput(lineId?: string): void {
+  validateLineId(lineId)
+}

package/src/domain/product/pricing.ts

@@ -0,0 +1,49 @@
+import { HttpTypes } from "@medusajs/types"
+import { getProductPrice, getPricesForVariant } from "@core/util/get-product-price"
+
+export type VariantPrice = NonNullable<ReturnType<typeof getPricesForVariant>>
+
+export function getDisplayPrice(
+  product: HttpTypes.StoreProduct,
+  selectedVariant?: HttpTypes.StoreProductVariant
+): VariantPrice | null {
+  if (selectedVariant) {
+    const variantPrice = getPricesForVariant(selectedVariant)
+    if (variantPrice) {
+      return variantPrice
+    }
+  }
+
+  const { cheapestPrice } = getProductPrice({ product })
+  return cheapestPrice
+}
+
+export function getDiscountPercentage(
+  displayPrice: VariantPrice | null | undefined
+): number | null {
+  const originalPrice = displayPrice?.original_price_number
+  const currentPrice = displayPrice?.calculated_price_number
+
+  if (originalPrice && currentPrice && originalPrice > currentPrice) {
+    return Math.round(((originalPrice - currentPrice) / originalPrice) * 100)
+  }
+
+  return null
+}
+
+export function formatINRPrice(amount: number): string {
+  return `₹${amount.toLocaleString("en-IN")}`
+}
+
+export function formatDisplayPrice(
+  displayPrice: VariantPrice,
+  currentPrice?: number | null
+): string {
+  if (currentPrice !== undefined && currentPrice !== null) {
+    return formatINRPrice(currentPrice)
+  }
+
+  return displayPrice.calculated_price
+}
+
+export { getProductPrice, getPricesForVariant }

package/src/domain/product/variant-selection.ts

@@ -0,0 +1,193 @@
+import { HttpTypes } from "@medusajs/types"
+import { isEqual } from "lodash"
+
+export type ProductOptions = Record<string, string | undefined>
+
+export function optionsAsKeymap(
+  variantOptions: HttpTypes.StoreProductVariant["options"]
+): ProductOptions | undefined {
+  return variantOptions?.reduce((acc: Record<string, string>, varopt) => {
+    if (varopt.option_id) {
+      acc[varopt.option_id] = varopt.value
+    }
+    return acc
+  }, {})
+}
+
+export function getAutoSelectPartialOptions(
+  product: HttpTypes.StoreProduct
+): Record<string, string> {
+  const partialOptions: Record<string, string> = {}
+
+  product.options?.forEach((option) => {
+    const uniqueValues = new Set(option.values?.map((v) => v.value))
+
+    if (uniqueValues.size === 1) {
+      const uniqueValue = Array.from(uniqueValues)[0]
+      if (uniqueValue) {
+        partialOptions[option.id] = uniqueValue
+      }
+    }
+  })
+
+  return partialOptions
+}
+
+export function getInitialOptions(
+  product: HttpTypes.StoreProduct,
+  variantIdFromUrl?: string | null
+): ProductOptions {
+  if (variantIdFromUrl && product.variants) {
+    const variantFromUrl = product.variants.find((v) => v.id === variantIdFromUrl)
+    if (variantFromUrl) {
+      return optionsAsKeymap(variantFromUrl.options) ?? {}
+    }
+  }
+
+  if (product.variants?.length === 1) {
+    return optionsAsKeymap(product.variants[0].options) ?? {}
+  }
+
+  const partialOptions = getAutoSelectPartialOptions(product)
+  if (Object.keys(partialOptions).length > 0) {
+    return partialOptions
+  }
+
+  return {}
+}
+
+export function findVariantByOptions(
+  product: HttpTypes.StoreProduct,
+  options: ProductOptions
+): HttpTypes.StoreProductVariant | undefined {
+  if (!product.variants || product.variants.length === 0) {
+    return undefined
+  }
+
+  return product.variants.find((v) => {
+    const variantOptions = optionsAsKeymap(v.options)
+    return isEqual(variantOptions, options)
+  })
+}
+
+export function isValidVariantSelection(
+  product: HttpTypes.StoreProduct,
+  options: ProductOptions
+): boolean {
+  return (
+    product.variants?.some((v) => {
+      const variantOptions = optionsAsKeymap(v.options)
+      return isEqual(variantOptions, options)
+    }) ?? false
+  )
+}
+
+export function findColorOption(
+  product: HttpTypes.StoreProduct
+): HttpTypes.StoreProductOption | undefined {
+  return product.options?.find(
+    (opt) =>
+      opt.title?.toLowerCase().includes("color") ||
+      opt.title?.toLowerCase().includes("colour")
+  )
+}
+
+export function findSizeOption(
+  product: HttpTypes.StoreProduct
+): HttpTypes.StoreProductOption | undefined {
+  return product.options?.find((opt) => opt.title?.toLowerCase().includes("size"))
+}
+
+export function getUniqueColorVariants(
+  product: HttpTypes.StoreProduct,
+  colorOption: HttpTypes.StoreProductOption
+): HttpTypes.StoreProductVariant[] {
+  if (!product.variants) {
+    return []
+  }
+
+  const uniqueColors = new Map<string, HttpTypes.StoreProductVariant>()
+  product.variants.forEach((variant) => {
+    const colorValue = variant.options?.find(
+      (opt) => opt.option_id === colorOption.id
+    )?.value
+    if (colorValue && !uniqueColors.has(colorValue)) {
+      uniqueColors.set(colorValue, variant)
+    }
+  })
+
+  return Array.from(uniqueColors.values())
+}
+
+export function getOtherOptions(
+  product: HttpTypes.StoreProduct
+): HttpTypes.StoreProductOption[] {
+  return (product.options || []).filter((opt) => {
+    const isColor =
+      opt.title?.toLowerCase().includes("color") ||
+      opt.title?.toLowerCase().includes("colour")
+    const isSize = opt.title?.toLowerCase().includes("size")
+    return !isColor && !isSize
+  })
+}
+
+export function getMissingOptionIds(
+  product: HttpTypes.StoreProduct,
+  options: ProductOptions
+): Record<string, boolean> {
+  const missingOptions: Record<string, boolean> = {}
+  product.options?.forEach((option) => {
+    if (!options[option.id]) {
+      missingOptions[option.id] = true
+    }
+  })
+  return missingOptions
+}
+
+export function isVariantInStock(
+  variant: HttpTypes.StoreProductVariant | undefined,
+  product: HttpTypes.StoreProduct,
+  quantity: number,
+  quantityInCart: number
+): boolean {
+  if (!variant) {
+    return Boolean(product.variants && product.variants.length > 0)
+  }
+
+  if (!variant.manage_inventory) {
+    return true
+  }
+
+  if (variant.allow_backorder) {
+    return true
+  }
+
+  const totalInventory = variant.inventory_quantity || 0
+  const availableQuantity = totalInventory - quantityInCart
+
+  return availableQuantity >= quantity
+}
+
+export function getInventoryLimit(
+  variant: HttpTypes.StoreProductVariant | undefined,
+  quantityInCart: number
+): number | null {
+  if (!variant || !variant.manage_inventory || variant.allow_backorder) {
+    return null
+  }
+
+  const totalInventory = variant.inventory_quantity || 0
+  return totalInventory - quantityInCart
+}
+
+export function getVariantCartItem(
+  cart: HttpTypes.StoreCart | null | undefined,
+  variantId: string | undefined
+): HttpTypes.StoreCartLineItem | null {
+  if (!cart || !variantId) {
+    return null
+  }
+
+  const item = cart.items?.find((i) => i.variant_id === variantId)
+  return item || null
+}

package/src/firebase.ts

@@ -0,0 +1,48 @@
+import { initializeApp, getApps, getApp } from "firebase/app"
+import { getMessaging, getToken, onMessage } from "firebase/messaging"
+
+const firebaseConfig = {
+  apiKey: process.env.NEXT_PUBLIC_FIREBASE_API_KEY,
+  authDomain: process.env.NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN,
+  projectId: process.env.NEXT_PUBLIC_FIREBASE_PROJECT_ID,
+  storageBucket: process.env.NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET,
+  messagingSenderId: process.env.NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID,
+  appId: process.env.NEXT_PUBLIC_FIREBASE_APP_ID,
+}
+
+const app = getApps().length > 0 ? getApp() : initializeApp(firebaseConfig)
+
+export const requestNotificationPermission = async () => {
+  try {
+    if (typeof window === "undefined" || !("Notification" in window)) {
+      return null
+    }
+
+    const permission = await Notification.requestPermission()
+    if (permission === "granted") {
+      // Explicitly register service worker to avoid path issues
+      const registration = await navigator.serviceWorker.register(
+        "/firebase-messaging-sw.js"
+      )
+
+      const messaging = getMessaging(app)
+      const token = await getToken(messaging, {
+        vapidKey: process.env.NEXT_PUBLIC_FIREBASE_VAPID_KEY,
+        serviceWorkerRegistration: registration,
+      })
+      return token
+    }
+  } catch (error) {
+    throw error // Throwing so UI can catch it
+  }
+}
+
+export const onMessageListener = () =>
+  new Promise((resolve) => {
+    const messaging = getMessaging(app)
+    onMessage(messaging, (payload) => {
+      resolve(payload)
+    })
+  })
+
+export default app

package/src/hooks/index.ts

@@ -0,0 +1,8 @@
+export { useAddToCart } from "./use-add-to-cart"
+export { useProductReviews } from "./use-product-reviews"
+export { useServerAction } from "./use-server-action"
+export { useCart } from "./use-cart"
+export { useProductVariant } from "./use-product-variant"
+export { useProductActions } from "./use-product-actions"
+export { useWishlist } from "./use-wishlist"
+export { useCheckout } from "./use-checkout"

package/src/hooks/use-add-to-cart.ts

@@ -0,0 +1,63 @@
+"use client"
+
+import { useState, useCallback } from "react"
+import { useParams } from "next/navigation"
+import { HttpTypes } from "@medusajs/types"
+import { addToCart } from "@core/data/cart"
+import { trackAddToCart } from "@core/analytics/ga4-ecommerce"
+
+type UseAddToCartOptions = {
+  region?: HttpTypes.StoreRegion
+}
+
+export function useAddToCart({ region }: UseAddToCartOptions = {}) {
+  const { countryCode } = useParams() as { countryCode: string }
+  const [isAdding, setIsAdding] = useState<string | null>(null)
+
+  const handleAddToCart = useCallback(
+    async (product: HttpTypes.StoreProduct) => {
+      if (!product.variants || product.variants.length === 0) return
+
+      const firstVariant = product.variants[0]
+      if (!firstVariant.id) return
+
+      setIsAdding(product.id || null)
+      try {
+        await addToCart({
+          variantId: firstVariant.id,
+          quantity: 1,
+          countryCode,
+        })
+        const currency =
+          (
+            firstVariant as { calculated_price?: { currency_code?: string } }
+          ).calculated_price?.currency_code?.toUpperCase() ??
+          region?.currency_code ??
+          "USD"
+        const unitPrice =
+          (firstVariant as { calculated_price?: { calculated_amount?: number } })
+            .calculated_price?.calculated_amount ?? 0
+        trackAddToCart({
+          currency,
+          value: unitPrice / 100,
+          items: [
+            {
+              item_id: firstVariant.id,
+              item_name: product.title ?? "",
+              price: unitPrice / 100,
+              quantity: 1,
+              item_variant: firstVariant.title ?? undefined,
+            },
+          ],
+        })
+      } catch {
+        // Silence error — caller may handle UI feedback
+      } finally {
+        setIsAdding(null)
+      }
+    },
+    [countryCode, region]
+  )
+
+  return { isAdding, handleAddToCart }
+}

package/src/hooks/use-cart.ts

@@ -0,0 +1,132 @@
+"use client"
+
+import { useCallback, useState } from "react"
+import { useParams } from "next/navigation"
+import {
+  addToCart,
+  updateLineItem,
+  deleteLineItem,
+  updateLineItemVariant,
+} from "@core/data/cart"
+
+type CartMutationResult = {
+  success: boolean
+  error?: string
+}
+
+export function useCart() {
+  const { countryCode } = useParams() as { countryCode: string }
+  const [loadingLineId, setLoadingLineId] = useState<string | null>(null)
+  const [isAdding, setIsAdding] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+
+  const addItem = useCallback(
+    async (variantId: string, quantity = 1): Promise<CartMutationResult> => {
+      setError(null)
+      setIsAdding(true)
+
+      try {
+        await addToCart({ variantId, quantity, countryCode })
+        return { success: true }
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : "Failed to add item to cart"
+        setError(message)
+        return { success: false, error: message }
+      } finally {
+        setIsAdding(false)
+      }
+    },
+    [countryCode]
+  )
+
+  const updateItem = useCallback(
+    async (lineId: string, quantity: number): Promise<CartMutationResult> => {
+      setError(null)
+      setLoadingLineId(lineId)
+
+      try {
+        await updateLineItem({ lineId, quantity })
+        return { success: true }
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : "Failed to update cart item"
+        setError(message)
+        return { success: false, error: message }
+      } finally {
+        setLoadingLineId(null)
+      }
+    },
+    []
+  )
+
+  const removeItem = useCallback(
+    async (lineId: string): Promise<CartMutationResult> => {
+      setError(null)
+      setLoadingLineId(lineId)
+
+      try {
+        await deleteLineItem(lineId)
+        return { success: true }
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : "Failed to remove cart item"
+        setError(message)
+        return { success: false, error: message }
+      } finally {
+        setLoadingLineId(null)
+      }
+    },
+    []
+  )
+
+  const updateItemVariant = useCallback(
+    async (
+      lineId: string,
+      variantId: string,
+      quantity: number
+    ): Promise<CartMutationResult> => {
+      setError(null)
+      setLoadingLineId(lineId)
+
+      try {
+        await updateLineItemVariant({
+          lineId,
+          variantId,
+          quantity,
+          countryCode,
+        })
+        return { success: true }
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : "Failed to update cart item variant"
+        setError(message)
+        return { success: false, error: message }
+      } finally {
+        setLoadingLineId(null)
+      }
+    },
+    [countryCode]
+  )
+
+  const clearError = useCallback(() => {
+    setError(null)
+  }, [])
+
+  const isLineLoading = useCallback(
+    (lineId: string) => loadingLineId === lineId,
+    [loadingLineId]
+  )
+
+  return {
+    addItem,
+    updateItem,
+    removeItem,
+    updateItemVariant,
+    isAdding,
+    loadingLineId,
+    isLineLoading,
+    error,
+    clearError,
+  }
+}

package/src/hooks/use-checkout.ts

@@ -0,0 +1,62 @@
+"use client"
+
+import { useCallback, useState } from "react"
+import { useParams, useRouter } from "next/navigation"
+import {
+  setAddresses,
+  placeOrder,
+  setShippingMethod,
+  initiatePaymentSession,
+} from "@core/data/cart"
+import { HttpTypes } from "@medusajs/types"
+import { useServerAction } from "./use-server-action"
+
+type UseCheckoutOptions = {
+  cart: HttpTypes.StoreCart
+}
+
+export function useCheckout({ cart }: UseCheckoutOptions) {
+  const router = useRouter()
+  const { countryCode } = useParams() as { countryCode: string }
+  const [isPlacingOrder, setIsPlacingOrder] = useState(false)
+
+  const addressAction = useServerAction((formData: FormData) =>
+    setAddresses(null, formData)
+  )
+
+  const handleSetShipping = useCallback(
+    async (shippingMethodId: string) => {
+      await setShippingMethod({ cartId: cart.id, shippingMethodId })
+      router.refresh()
+    },
+    [cart.id, router]
+  )
+
+  const handleInitiatePayment = useCallback(
+    async (data: HttpTypes.StoreInitializePaymentSession) => {
+      return initiatePaymentSession(cart, data)
+    },
+    [cart]
+  )
+
+  const handlePlaceOrder = useCallback(
+    async (cartId?: string) => {
+      setIsPlacingOrder(true)
+      try {
+        await placeOrder(cartId ?? cart.id)
+      } finally {
+        setIsPlacingOrder(false)
+      }
+    },
+    [cart.id]
+  )
+
+  return {
+    countryCode,
+    isPlacingOrder,
+    addressAction,
+    handleSetShipping,
+    handleInitiatePayment,
+    handlePlaceOrder,
+  }
+}

package/src/hooks/use-in-view.tsx

@@ -0,0 +1,29 @@
+import { RefObject, useEffect, useState } from "react"
+
+export const useIntersection = (
+  element: RefObject<HTMLDivElement | null>,
+  rootMargin: string
+) => {
+  const [isVisible, setState] = useState(false)
+
+  useEffect(() => {
+    if (!element.current) {
+      return
+    }
+
+    const el = element.current
+
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        setState(entry.isIntersecting)
+      },
+      { rootMargin }
+    )
+
+    observer.observe(el)
+
+    return () => observer.unobserve(el)
+  }, [element, rootMargin])
+
+  return isVisible
+}