@pradip1995/commerce-core 1.0.0

package/README.md

@@ -0,0 +1,15 @@
+# @pradip1995/commerce-core
+
+Medusa storefront commerce logic: server actions, domain rules, hooks, types.
+
+## Exports
+
+```ts
+import { sdk } from "@pradip1995/commerce-core/config"
+import { useAddToCart } from "@pradip1995/commerce-core/hooks/use-add-to-cart"
+import type { HomePageData } from "@pradip1995/commerce-core/types/home"
+```
+
+## Peer dependencies
+
+`next`, `react`, `@medusajs/js-sdk`, `@medusajs/types`

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@pradip1995/commerce-core",
+  "version": "1.0.0",
+  "description": "Medusa storefront commerce logic — data, domain, hooks, types, utils",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SmartByteLabs/medusa-storefront-kit.git",
+    "directory": "packages/commerce-core"
+  },
+  "sideEffects": false,
+  "files": [
+    "src"
+  ],
+  "exports": {
+    "./config": "./src/config.ts",
+    "./constants": "./src/constants.tsx",
+    "./firebase": "./src/firebase.ts",
+    "./analytics/ga4-ecommerce": "./src/analytics/ga4-ecommerce.ts",
+    "./context/*": "./src/context/*.tsx",
+    "./data/*": "./src/data/*.ts",
+    "./data/cart": "./src/data/cart/index.ts",
+    "./domain/cart": "./src/domain/cart/index.ts",
+    "./domain/product/*": "./src/domain/product/*.ts",
+    "./hooks": "./src/hooks/index.ts",
+    "./hooks/*": "./src/hooks/*",
+    "./types/*": "./src/types/*.ts",
+    "./util/*": "./src/util/*.ts",
+    "./theme/inline-vars": "./src/theme/inline-vars.ts"
+  },
+  "peerDependencies": {
+    "@medusajs/js-sdk": ">=2",
+    "@medusajs/types": ">=2",
+    "next": ">=15",
+    "react": ">=19",
+    "react-dom": ">=19"
+  },
+  "dependencies": {
+    "country-state-city": "^3.2.1",
+    "firebase": "^12.8.0",
+    "lodash": "^4.17.21",
+    "pg": "^8.11.3",
+    "qs": "^6.12.1",
+    "server-only": "^0.0.1"
+  },
+  "devDependencies": {
+    "@medusajs/icons": "latest",
+    "@medusajs/js-sdk": "latest",
+    "@medusajs/types": "latest",
+    "@types/lodash": "^4.17.0",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "color": "^5.0.3",
+    "eslint": "^8.57.0",
+    "next": "15.3.8",
+    "react": "19.0.3",
+    "react-dom": "19.0.3",
+    "typescript": "^5.7.2"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.typecheck.json",
+    "typecheck:full": "tsc --noEmit",
+    "lint": "tsc --noEmit -p tsconfig.typecheck.json"
+  }
+}

package/src/analytics/ga4-ecommerce.ts

@@ -0,0 +1,96 @@
+/**
+ * GA4 E-commerce event helpers for dataLayer.
+ * Use these to power GA4 "Drive sales" reports: Ecommerce purchases,
+ * Purchase journey, Checkout journey, Transactions, Promotions.
+ */
+
+export type GA4Item = {
+  item_id: string
+  item_name: string
+  price?: number
+  quantity?: number
+  index?: number
+  item_variant?: string
+}
+
+function pushToDataLayer(obj: Record<string, unknown>) {
+  if (typeof window === "undefined") return
+  const w = window as Window & { dataLayer?: unknown[] }
+  w.dataLayer = w.dataLayer || []
+  w.dataLayer.push(obj)
+}
+
+export function trackAddToCart(payload: {
+  currency: string
+  value: number
+  items: GA4Item[]
+}) {
+  pushToDataLayer({ event: "add_to_cart", ecommerce: payload })
+}
+
+export function trackRemoveFromCart(payload: {
+  currency: string
+  value: number
+  items: GA4Item[]
+}) {
+  pushToDataLayer({ event: "remove_from_cart", ecommerce: payload })
+}
+
+export function trackViewCart(payload: {
+  currency: string
+  value: number
+  items: GA4Item[]
+}) {
+  pushToDataLayer({ event: "view_cart", ecommerce: payload })
+}
+
+export function trackViewItem(payload: {
+  currency: string
+  value: number
+  items: GA4Item[]
+}) {
+  pushToDataLayer({ event: "view_item", ecommerce: payload })
+}
+
+export function trackViewItemList(payload: {
+  list_id?: string
+  list_name?: string
+  items: GA4Item[]
+}) {
+  pushToDataLayer({ event: "view_item_list", ecommerce: payload })
+}
+
+export function trackBeginCheckout(payload: {
+  currency: string
+  value: number
+  items: GA4Item[]
+}) {
+  pushToDataLayer({ event: "begin_checkout", ecommerce: payload })
+}
+
+export function trackAddShippingInfo(payload: {
+  currency: string
+  value: number
+  items: GA4Item[]
+}) {
+  pushToDataLayer({ event: "add_shipping_info", ecommerce: payload })
+}
+
+export function trackAddPaymentInfo(payload: {
+  currency: string
+  value: number
+  items: GA4Item[]
+}) {
+  pushToDataLayer({ event: "add_payment_info", ecommerce: payload })
+}
+
+export function trackPurchase(payload: {
+  transaction_id: string
+  currency: string
+  value: number
+  tax?: number
+  shipping?: number
+  items: GA4Item[]
+}) {
+  pushToDataLayer({ event: "purchase", ecommerce: payload })
+}

package/src/config.ts

@@ -0,0 +1,36 @@
+import { getLocaleHeader } from "@core/util/get-locale-header"
+import Medusa, { FetchArgs, FetchInput } from "@medusajs/js-sdk"
+
+// Defaults to standard port for Medusa server
+let MEDUSA_BACKEND_URL = "http://localhost:9000"
+
+if (process.env.MEDUSA_BACKEND_URL) {
+  MEDUSA_BACKEND_URL = process.env.MEDUSA_BACKEND_URL
+}
+
+export const sdk = new Medusa({
+  baseUrl: MEDUSA_BACKEND_URL,
+  debug: process.env.NODE_ENV === "development",
+  publishableKey: process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY,
+})
+
+const originalFetch = sdk.client.fetch.bind(sdk.client)
+
+sdk.client.fetch = async <T>(input: FetchInput, init?: FetchArgs): Promise<T> => {
+  const headers = init?.headers ?? {}
+  let localeHeader: Record<string, string | null> | undefined
+  try {
+    localeHeader = await getLocaleHeader()
+    headers["x-medusa-locale"] ??= localeHeader["x-medusa-locale"]
+  } catch {}
+
+  const newHeaders = {
+    ...localeHeader,
+    ...headers,
+  }
+  init = {
+    ...init,
+    headers: newHeaders,
+  }
+  return originalFetch(input, init)
+}

package/src/constants.tsx

@@ -0,0 +1,84 @@
+import React from "react"
+import { CreditCard } from "@medusajs/icons"
+
+import Ideal from "@modules/common/icons/ideal"
+import Bancontact from "@modules/common/icons/bancontact"
+import PayPal from "@modules/common/icons/paypal"
+
+/* Map of payment provider_id to their title and icon. Add in any payment providers you want to use. */
+export const paymentInfoMap: Record<
+  string,
+  { title: string; icon: React.JSX.Element }
+> = {
+  pp_stripe_stripe: {
+    title: "Credit card",
+    icon: <CreditCard />,
+  },
+  "pp_medusa-payments_default": {
+    title: "Credit card",
+    icon: <CreditCard />,
+  },
+  "pp_stripe-ideal_stripe": {
+    title: "iDeal",
+    icon: <Ideal />,
+  },
+  "pp_stripe-bancontact_stripe": {
+    title: "Bancontact",
+    icon: <Bancontact />,
+  },
+  pp_paypal_paypal: {
+    title: "PayPal",
+    icon: <PayPal />,
+  },
+  pp_system_default: {
+    title: "Cash on Delivery (Cash/UPI)",
+    icon: <CreditCard />,
+  },
+  razorpay: {
+    title: "Razorpay",
+    icon: <CreditCard />,
+  },
+  pp_razorpay_razorpay: {
+    title: "Razorpay",
+    icon: <CreditCard />,
+  },
+  // Add more payment providers here
+}
+
+// This only checks if it is native stripe or medusa payments for card payments, it ignores the other stripe-based providers
+export const isStripeLike = (providerId?: string) => {
+  return providerId?.startsWith("pp_stripe_") || providerId?.startsWith("pp_medusa-")
+}
+
+export const isPaypal = (providerId?: string) => {
+  return providerId?.startsWith("pp_paypal")
+}
+export const isManual = (providerId?: string) => {
+  return providerId?.startsWith("pp_system_default")
+}
+export const isRazorpay = (providerId?: string) => {
+  return providerId?.startsWith("razorpay") || providerId?.startsWith("pp_razorpay")
+}
+
+// Add currencies that don't need to be divided by 100
+export const noDivisionCurrencies = [
+  "krw",
+  "jpy",
+  "vnd",
+  "clp",
+  "pyg",
+  "xaf",
+  "xof",
+  "bif",
+  "djf",
+  "gnf",
+  "kmf",
+  "mga",
+  "rwf",
+  "xpf",
+  "htg",
+  "vuv",
+  "xag",
+  "xdr",
+  "xau",
+]

package/src/context/modal-context.tsx

@@ -0,0 +1,40 @@
+"use client"
+
+import React, { createContext, useContext, useState } from "react"
+
+interface ModalContextType {
+  isModalOpen: boolean
+  setIsModalOpen: (isOpen: boolean) => void
+  close: () => void
+}
+
+const ModalContext = createContext<ModalContextType | undefined>(undefined)
+
+export const ModalProvider: React.FC<{
+  children: React.ReactNode
+  close?: () => void
+}> = ({ children, close: closeProp }) => {
+  const [isModalOpen, setIsModalOpen] = useState(false)
+
+  const close = () => {
+    if (closeProp) {
+      closeProp()
+    } else {
+      setIsModalOpen(false)
+    }
+  }
+
+  return (
+    <ModalContext.Provider value={{ isModalOpen, setIsModalOpen, close }}>
+      {children}
+    </ModalContext.Provider>
+  )
+}
+
+export const useModal = () => {
+  const context = useContext(ModalContext)
+  if (context === undefined) {
+    throw new Error("useModal must be used within a ModalProvider")
+  }
+  return context
+}

package/src/context/wishlist-context.tsx

@@ -0,0 +1,96 @@
+"use client"
+
+import React, {
+  createContext,
+  useContext,
+  useState,
+  useEffect,
+  useCallback,
+} from "react"
+import {
+  getWishlistProductIds,
+  addToWishlist as addToWishlistApi,
+  removeFromWishlist as removeFromWishlistApi,
+} from "@core/data/wishlist"
+
+interface WishlistContextType {
+  wishlistIds: string[]
+  count: number
+  isWishlisted: (productId: string) => boolean
+  toggleWishlist: (productId: string) => Promise<{ success: boolean; error?: string }>
+  refreshWishlist: () => Promise<void>
+}
+
+const WishlistContext = createContext<WishlistContextType | undefined>(undefined)
+
+export const WishlistProvider: React.FC<{ children: React.ReactNode }> = ({
+  children,
+}) => {
+  const [wishlistIds, setWishlistIds] = useState<string[]>([])
+
+  const refreshWishlist = useCallback(async () => {
+    try {
+      const ids = await getWishlistProductIds()
+      setWishlistIds(ids)
+    } catch (error) {
+      // Error silently ignored for production
+    }
+  }, [])
+
+  useEffect(() => {
+    refreshWishlist()
+  }, [refreshWishlist])
+
+  const isWishlisted = useCallback(
+    (productId: string) => {
+      return wishlistIds.includes(productId)
+    },
+    [wishlistIds]
+  )
+
+  const toggleWishlist = async (productId: string) => {
+    const currentlyWishlisted = isWishlisted(productId)
+
+    try {
+      if (currentlyWishlisted) {
+        const result = await removeFromWishlistApi(productId)
+        if (result.success) {
+          setWishlistIds((prev) => prev.filter((id) => id !== productId))
+          return { success: true }
+        }
+        return { success: false, error: result.error }
+      } else {
+        const result = await addToWishlistApi(productId)
+        if (result.success) {
+          setWishlistIds((prev) => [...prev, productId])
+          return { success: true }
+        }
+        return { success: false, error: result.error }
+      }
+    } catch (error: any) {
+      return { success: false, error: error.message || "An error occurred" }
+    }
+  }
+
+  return (
+    <WishlistContext.Provider
+      value={{
+        wishlistIds,
+        count: wishlistIds.length,
+        isWishlisted,
+        toggleWishlist,
+        refreshWishlist,
+      }}
+    >
+      {children}
+    </WishlistContext.Provider>
+  )
+}
+
+export const useWishlist = () => {
+  const context = useContext(WishlistContext)
+  if (context === undefined) {
+    throw new Error("useWishlist must be used within a WishlistProvider")
+  }
+  return context
+}

package/src/data/cart/abandoned.ts

@@ -0,0 +1,111 @@
+"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 getAbandonedCarts() {
+  const headers = {
+    ...(await getAuthHeaders()),
+  }
+
+  // If no authorization, return empty arrays
+  if (!headers["authorization"]) {
+    return { buyNowCarts: [], reorderCarts: [] }
+  }
+
+  try {
+    // Just fetch all carts for the customer and filter locally
+    const res = await sdk.client
+      .fetch<{ carts: HttpTypes.StoreCart[] }>(`/store/carts`, {
+        method: "GET",
+        query: {
+          fields:
+            "*items, *items.product, *items.product.thumbnail, *items.variant, *items.metadata, +total",
+        },
+        headers,
+        cache: "no-store",
+      })
+      .catch(() => null)
+
+    let buyNowCarts: HttpTypes.StoreCart[] = []
+    let reorderCarts: HttpTypes.StoreCart[] = []
+
+    if (res?.carts) {
+      const currentCartId = await getCartId()
+      const filteredCarts = filterOutCurrentCart(res.carts, currentCartId)
+      const partitioned = partitionAbandonedCarts(filteredCarts)
+
+      buyNowCarts = partitioned.buyNowCarts
+      reorderCarts = partitioned.reorderCarts
+    }
+
+    return { buyNowCarts, reorderCarts }
+  } catch (e) {
+    console.error("Failed to fetch abandoned carts:", e)
+    return { buyNowCarts: [], reorderCarts: [] }
+  }
+}
+
+export async function resumeAbandonedCart(cartId: string, countryCode: string) {
+  // Set as buy now cart so it temporarily overrides the main cart
+  // without deleting the main cart cookie (_medusa_cart_id)
+  await setBuyNowCartId(cartId)
+
+  redirect(getResumeAbandonedCheckoutUrl(countryCode, cartId))
+}
+
+export async function deleteCart(cartId: string) {
+  const headers = await getAuthHeaders()
+
+  try {
+    await sdk.client.fetch(`/store/carts/${cartId}`, {
+      method: "DELETE",
+      headers,
+      cache: "no-store",
+    })
+
+    revalidateTag("carts")
+    return { success: true }
+  } catch (e: any) {
+    console.error("Failed to delete cart:", e)
+    return { success: false, error: e.message }
+  }
+}