@pradip1995/commerce-core 1.0.0

package/src/data/collections.ts

@@ -0,0 +1,109 @@
+"use server"
+
+import { sdk } from "@core/config"
+import { HttpTypes } from "@medusajs/types"
+import { getCacheOptions } from "./cookies"
+
+export const retrieveCollection = async (id: string) => {
+  const next = {
+    ...(await getCacheOptions("collections")),
+  }
+
+  return sdk.client
+    .fetch<{ collection: HttpTypes.StoreCollection }>(`/store/collections/${id}`, {
+      next: {
+        ...next,
+        revalidate: 0,
+      },
+      cache: "no-store",
+    })
+    .then(({ collection }) => collection)
+}
+
+export const listCollections = async (
+  queryParams: Record<string, string> = {}
+): Promise<{ collections: HttpTypes.StoreCollection[]; count: number }> => {
+  try {
+    const next = {
+      ...(await getCacheOptions("collections")),
+    }
+
+    queryParams.limit = queryParams.limit || "100"
+    queryParams.offset = queryParams.offset || "0"
+
+    return sdk.client
+      .fetch<{ collections: HttpTypes.StoreCollection[]; count: number }>(
+        "/store/collections",
+        {
+          query: queryParams,
+          next: {
+            ...next,
+            revalidate: 0,
+          },
+          cache: "no-store",
+        }
+      )
+      .then(({ collections }) => ({ collections, count: collections.length }))
+      .catch((error) => {
+        if (process.env.NODE_ENV === "production" || process.env.CI) {
+          return { collections: [], count: 0 }
+        }
+        throw error
+      })
+  } catch (error: any) {
+    if (process.env.NODE_ENV === "production" || process.env.CI) {
+      return { collections: [], count: 0 }
+    }
+    throw error
+  }
+}
+
+export const getCollectionByHandle = async (
+  handle: string
+): Promise<HttpTypes.StoreCollection | null> => {
+  try {
+    const next = {
+      ...(await getCacheOptions("collections")),
+    }
+
+    // Ensure handle is decoded
+    const decodedHandle = decodeURIComponent(handle)
+
+    // Try array-based handle filter (standard for v2)
+    const result = await sdk.client.fetch<HttpTypes.StoreCollectionListResponse>(
+      `/store/collections`,
+      {
+        query: {
+          handle: [decodedHandle],
+        },
+        next: {
+          ...next,
+          revalidate: 0,
+        },
+        cache: "no-store",
+      }
+    )
+
+    if (result.collections && result.collections.length > 0) {
+      return result.collections[0]
+    }
+
+    // Fallback: Fetch all and find manually (useful for handles with spaces/special chars)
+
+    const { collections } = await listCollections({ limit: "100" })
+    const matchedCollection = collections.find(
+      (c) =>
+        c.handle === decodedHandle ||
+        c.handle === handle ||
+        c.handle?.replace(/-/g, " ") === decodedHandle
+    )
+
+    if (matchedCollection) {
+      return matchedCollection
+    }
+
+    return null
+  } catch (error: any) {
+    return null
+  }
+}

package/src/data/contact.ts

@@ -0,0 +1,143 @@
+"use server"
+
+const getBaseUrl = () => {
+  return process.env.MEDUSA_BACKEND_URL || "http://localhost:9000"
+}
+
+const getPublishableKey = () => {
+  return process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY
+}
+
+/**
+ * Submit a contact request
+ */
+export async function submitContactRequest({
+  email,
+  payload,
+  metadata,
+  source = "storefront",
+}: {
+  email: string
+  payload: {
+    full_name?: string
+    phone?: string
+    topic?: string
+    subject?: string
+    message: string
+  }
+  metadata?: Record<string, any>
+  source?: string
+}) {
+  try {
+    const publishableKey = getPublishableKey()
+    const baseUrl = getBaseUrl()
+
+    if (!publishableKey) {
+      return {
+        success: false,
+        error: "Configuration error: Publishable API key is missing.",
+      }
+    }
+
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      "x-publishable-api-key": publishableKey,
+    }
+
+    const requestBody: any = {
+      email,
+      payload,
+      source,
+    }
+
+    if (metadata) {
+      requestBody.metadata = metadata
+    }
+
+    const response = await fetch(`${baseUrl}/store/contact-requests`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(requestBody),
+    })
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: "Unknown error" }))
+      return {
+        success: false,
+        error:
+          error.message || `HTTP ${response.status}: Failed to submit contact request`,
+      }
+    }
+
+    const data = await response.json()
+    return {
+      success: true,
+      data,
+    }
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message || "An error occurred while submitting the contact request",
+    }
+  }
+}
+
+/**
+ * Subscribe to email newsletter
+ */
+export async function subscribeToNewsletter({
+  email,
+  status = "subscribed",
+  source = "footer",
+}: {
+  email: string
+  status?: "subscribed" | "unsubscribed"
+  source?: string
+}) {
+  try {
+    const publishableKey = getPublishableKey()
+    const baseUrl = getBaseUrl()
+
+    if (!publishableKey) {
+      return {
+        success: false,
+        error: "Configuration error: Publishable API key is missing.",
+      }
+    }
+
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      "x-publishable-api-key": publishableKey,
+    }
+
+    const response = await fetch(`${baseUrl}/store/contact-email-subscriptions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        email,
+        status,
+        source,
+      }),
+    })
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: "Unknown error" }))
+      return {
+        success: false,
+        error:
+          error.message || `HTTP ${response.status}: Failed to subscribe to newsletter`,
+      }
+    }
+
+    const data = await response.json()
+    return {
+      success: true,
+      data,
+    }
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message || "An error occurred while subscribing to newsletter",
+    }
+  }
+}

package/src/data/cookies.ts

@@ -0,0 +1,170 @@
+import "server-only"
+import { cookies as nextCookies, headers } from "next/headers"
+
+export const getAuthHeaders = async (): Promise<{ authorization: string } | {}> => {
+  try {
+    const cookies = await nextCookies()
+    const token = cookies.get("_medusa_jwt")?.value
+
+    if (!token) {
+      return {}
+    }
+
+    return { authorization: `Bearer ${token}` }
+  } catch {
+    return {}
+  }
+}
+
+export const getGuestAuthHeaders = async (): Promise<
+  { authorization: string } | {}
+> => {
+  try {
+    const cookies = await nextCookies()
+    const token = cookies.get("_medusa_guest_jwt")?.value
+
+    if (!token) {
+      return {}
+    }
+
+    return { authorization: `Bearer ${token}` }
+  } catch {
+    return {}
+  }
+}
+
+export const getCacheTag = async (tag: string): Promise<string> => {
+  try {
+    const cookies = await nextCookies()
+    const cacheId = cookies.get("_medusa_cache_id")?.value
+
+    if (!cacheId) {
+      return ""
+    }
+
+    return `${tag}-${cacheId}`
+  } catch (error) {
+    return ""
+  }
+}
+
+export const getCacheOptions = async (
+  tag: string
+): Promise<{ tags: string[] } | {}> => {
+  if (typeof window !== "undefined") {
+    return {}
+  }
+
+  const cacheTag = await getCacheTag(tag)
+
+  if (!cacheTag) {
+    return {}
+  }
+
+  return { tags: [`${cacheTag}`] }
+}
+
+export const setAuthToken = async (token: string) => {
+  const cookies = await nextCookies()
+  cookies.set("_medusa_jwt", token, {
+    maxAge: 60 * 60 * 24 * 7,
+    httpOnly: true,
+    sameSite: "strict",
+    secure: process.env.NODE_ENV === "production",
+  })
+}
+
+export const removeAuthToken = async () => {
+  const cookies = await nextCookies()
+  cookies.set("_medusa_jwt", "", {
+    maxAge: -1,
+  })
+}
+
+export const getCartId = async () => {
+  const cookies = await nextCookies()
+  const headerList = await headers()
+
+  // Check for x-cart-id header FIRST (as it's the most up-to-date from middleware)
+  const headerId = headerList.get("x-cart-id")
+  if (headerId) {
+    return headerId
+  }
+
+  // Prioritize buy_now_cart_id if it exists
+  const buyNowId = cookies.get("buy_now_cart_id")?.value
+  if (buyNowId) {
+    return buyNowId
+  }
+
+  // Fallback to regular cart cookies
+  const id =
+    cookies.get("_medusa_cart_id")?.value ||
+    cookies.get("cart_id")?.value ||
+    cookies.get("medusa_cart_id")?.value
+
+  return id
+}
+
+export const setCartId = async (cartId: string) => {
+  const cookies = await nextCookies()
+  cookies.set("_medusa_cart_id", cartId, {
+    maxAge: 60 * 60 * 24 * 7,
+    httpOnly: true,
+    sameSite: "strict",
+    secure: process.env.NODE_ENV === "production",
+  })
+}
+
+export const removeCartId = async () => {
+  const cookies = await nextCookies()
+  cookies.set("_medusa_cart_id", "", {
+    maxAge: -1,
+  })
+}
+
+export const removeSyncLock = async () => {
+  const cookies = await nextCookies()
+  cookies.set("_medusa_cart_synced", "", {
+    maxAge: -1,
+  })
+}
+
+export const setHoldCartId = async (cartId: string) => {
+  const cookies = await nextCookies()
+  cookies.set("_medusa_hold_cart_id", cartId, {
+    maxAge: 60 * 60 * 24,
+    httpOnly: true,
+    sameSite: "strict",
+    secure: process.env.NODE_ENV === "production",
+  })
+}
+
+export const getHoldCartId = async () => {
+  const cookies = await nextCookies()
+  return cookies.get("_medusa_hold_cart_id")?.value
+}
+
+export const removeHoldCartId = async () => {
+  const cookies = await nextCookies()
+  cookies.set("_medusa_hold_cart_id", "", {
+    maxAge: -1,
+  })
+}
+
+export const setBuyNowCartId = async (cartId: string) => {
+  const cookies = await nextCookies()
+  cookies.set("buy_now_cart_id", cartId, {
+    maxAge: 60 * 60 * 24 * 7,
+    httpOnly: true,
+    sameSite: "strict",
+    secure: process.env.NODE_ENV === "production",
+  })
+}
+
+export const removeBuyNowCartId = async () => {
+  const cookies = await nextCookies()
+  cookies.set("buy_now_cart_id", "", {
+    maxAge: -1,
+  })
+}