medusa-storefront-data 1.0.0 → 2.0.0

package/src/server/customer.ts

@@ -1,6 +1,5 @@
 "use server"
 
-import { sdk } from "../config"
 import medusaError from "../util/medusa-error"
 import { HttpTypes } from "@medusajs/types"
 import { revalidateTag } from "next/cache"
@@ -8,7 +7,6 @@ import { redirect } from "next/navigation"
 import { cookies } from "next/headers"
 import {
   getAuthHeaders,
-  getCacheOptions,
   getCacheTag,
   getCartId,
   removeAuthToken,
@@ -17,35 +15,48 @@ import {
   setAuthToken,
   setCartId,
 } from "../cookies"
+import {
+  medusaAuthLogin,
+  medusaAuthLogout,
+  medusaAuthRegister,
+} from "medusa-services/auth"
+import {
+  isAccountDeletionPendingError,
+  medusaCustomerCreate,
+  medusaCustomerCreateAddress,
+  medusaCustomerDeleteAddress,
+  medusaCustomerRetrieve,
+  medusaCustomerUpdate,
+  medusaCustomerUpdateAddress,
+} from "medusa-services/customer"
+import { medusaCartMerge, medusaCartTransfer } from "medusa-services/cart"
+import {
+  getAuthClientOptions,
+  getMedusaBackendUrl,
+  getStoreCartClientOptions,
+} from "../util/store-client"
 
 import { cache } from "react"
 
+function throwCustomerError(error: unknown): never {
+  if (error && typeof error === "object" && "response" in error) {
+    medusaError(error)
+  }
+  throw error instanceof Error ? error : new Error(String(error))
+}
+
 export const retrieveCustomer = cache(
   async (): Promise<HttpTypes.StoreCustomer | null> => {
     const authHeaders = await getAuthHeaders()
 
-    if (!authHeaders) return null
-
-    const headers = {
-      ...authHeaders,
-    }
+    if (!("authorization" in authHeaders)) return null
 
     try {
-      const { customer } = await sdk.client.fetch<{ customer: HttpTypes.StoreCustomer }>(
-        `/store/customers/me`,
-        {
-          method: "GET",
-          query: { fields: "*addresses" },
-          headers: headers as Record<string, string>,
-          cache: "no-store",
-        }
-      )
-      return customer
-    } catch (error: any) {
-      const errStr = error.toString().toLowerCase()
-      // If the error indicates a pending deletion, return a special object
-      if (errStr.includes("active account deletion request") ||
-        (error.message && error.message.toLowerCase().includes("active account deletion request"))) {
+      const options = await getStoreCartClientOptions()
+      const { customer } = await medusaCustomerRetrieve(options, { fields: "*addresses" })
+      return customer as unknown as HttpTypes.StoreCustomer
+    } catch (error: unknown) {
+      if (isAccountDeletionPendingError(error)) {
         const cookieStore = await cookies()
         const cookieEmail = cookieStore.get("_medusa_customer_email")?.value
         return { id: "pending_deletion", email: cookieEmail || "pending" } as any
@@ -56,19 +67,17 @@ export const retrieveCustomer = cache(
 )
 
 export const updateCustomer = async (body: HttpTypes.StoreUpdateCustomer) => {
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
-
-  const updateRes = await sdk.store.customer
-    .update(body, {}, headers)
-    .then(({ customer }) => customer)
-    .catch(medusaError)
+  try {
+    const options = await getStoreCartClientOptions()
+    const { customer } = await medusaCustomerUpdate(body as Record<string, unknown>, options)
 
-  const cacheTag = await getCacheTag("customers")
-  revalidateTag(cacheTag)
+    const cacheTag = await getCacheTag("customers")
+    revalidateTag(cacheTag)
 
-  return updateRes
+    return customer as unknown as HttpTypes.StoreCustomer
+  } catch (e) {
+    throwCustomerError(e)
+  }
 }
 
 export async function signup(_currentState: unknown, formData: FormData) {
@@ -81,34 +90,28 @@ export async function signup(_currentState: unknown, formData: FormData) {
   }
 
   try {
-    const token = await sdk.auth.register("customer", "emailpass", {
-      email: customerForm.email,
-      password: password,
-    })
+    const authOptions = await getAuthClientOptions()
+    const token = await medusaAuthRegister(
+      { email: customerForm.email, password },
+      authOptions
+    )
 
-    await setAuthToken(token as string)
+    await setAuthToken(token)
 
-    const headers = {
-      ...(await getAuthHeaders()),
-    }
+    const options = await getStoreCartClientOptions()
+    const { customer: createdCustomer } = await medusaCustomerCreate(customerForm, options)
 
-    const { customer: createdCustomer } = await sdk.store.customer.create(
-      customerForm,
-      {},
-      headers
+    const loginToken = await medusaAuthLogin(
+      { email: customerForm.email, password },
+      authOptions
     )
 
-    const loginToken = await sdk.auth.login("customer", "emailpass", {
-      email: customerForm.email,
-      password,
-    })
-
-    await setAuthToken(loginToken as string)
+    await setAuthToken(loginToken)
 
     const customerCacheTag = await getCacheTag("customers")
     revalidateTag(customerCacheTag)
 
-    await transferCart(loginToken as string)
+    await transferCart(loginToken)
 
     return createdCustomer
   } catch (error: any) {
@@ -120,8 +123,6 @@ export async function login(_currentState: unknown, formData: FormData) {
   let email = formData.get("email_or_phone") as string
   const password = formData.get("password") as string
 
-  // Sanitize phone number: remove spaces, dashes, etc if it looks like a phone number
-  // If it doesn't have '@', we treat it as a potential phone number and clean it
   if (email && !email.includes("@")) {
     email = email.replace(/[^\d+]/g, "")
   }
@@ -130,30 +131,28 @@ export async function login(_currentState: unknown, formData: FormData) {
   let countryCode = "in"
 
   try {
-    const token = await sdk.auth.login("customer", "emailpass", { email_or_phone: email, password })
-    await setAuthToken(token as string)
+    const authOptions = await getAuthClientOptions()
+    const token = await medusaAuthLogin({ email_or_phone: email, password }, authOptions)
+    await setAuthToken(token)
 
-    // Store email in cookie for deletion flow (needed for cancellation modal)
     const cookieStore = await cookies()
     cookieStore.set("_medusa_customer_email", email, { maxAge: 60 * 60 * 24 * 7, path: "/" })
 
-    // Force a check to see if we are blocked
     try {
-      await sdk.store.customer.retrieve({}, {
-        authorization: `Bearer ${token}`
+      const options = await getStoreCartClientOptions()
+      await medusaCustomerRetrieve({
+        ...options,
+        authorization: `Bearer ${token}`,
       })
-    } catch (err: any) {
-      const errStr = err.toString().toLowerCase()
-      if (errStr.includes("active account deletion request")) {
+    } catch (err: unknown) {
+      if (isAccountDeletionPendingError(err)) {
         return "ACCOUNT_DELETION_PENDING"
       }
-      // If it's another error, we might still want to know, but deletion is our priority
       throw err
     }
 
-    // Transfer cart after login success - Moved here to ensure execution
     try {
-      await transferCart(token as string)
+      await transferCart(token)
     } catch (e) {
       console.error("Transfer cart failed in login:", e)
     }
@@ -161,43 +160,42 @@ export async function login(_currentState: unknown, formData: FormData) {
     const customerCacheTag = await getCacheTag("customers")
     revalidateTag(customerCacheTag)
 
-    countryCode = formData.get("country_code") as string || "in"
+    countryCode = (formData.get("country_code") as string) || "in"
     shouldRedirect = true
-  } catch (error: any) {
-    const errorStr = error.toString().toLowerCase()
-
-    if (errorStr.includes("active account deletion request") ||
-      (error.message && error.message.toLowerCase().includes("active account deletion request"))) {
-      // Still set email cookie even if blocked
+  } catch (error: unknown) {
+    if (isAccountDeletionPendingError(error)) {
       const cookieStore = await cookies()
       cookieStore.set("_medusa_customer_email", email, { maxAge: 60 * 60 * 24 * 7, path: "/" })
       return "ACCOUNT_DELETION_PENDING"
     }
 
+    const errorStr = String(error).toLowerCase()
     if (errorStr.includes("invalid") || errorStr.includes("401") || errorStr.includes("not found")) {
       return "Invalid credentials. Please try again."
     }
-    return error.message || error.toString()
+
+    return error instanceof Error ? error.message : String(error)
   }
 
   if (shouldRedirect) {
     const redirectUrl = formData.get("redirect_url") as string
-
-    // Check if it's a "keep-me-here" context (Wishlist or Review Popups)
     const hasKeepContext = redirectUrl?.includes("login_context=keep")
 
-    // Security + Context check
     if (redirectUrl && redirectUrl.startsWith("/") && hasKeepContext) {
       redirect(redirectUrl)
     } else {
-      // DEFAULT: Always Home Page
       redirect(`/${countryCode}`)
     }
   }
 }
 
 export async function signout(countryCode: string) {
-  await sdk.auth.logout()
+  try {
+    const authOptions = await getAuthClientOptions()
+    await medusaAuthLogout(authOptions)
+  } catch {
+    // Continue local cleanup even if remote logout fails
+  }
 
   await removeAuthToken()
   await removeCartId()
@@ -216,58 +214,38 @@ export async function signout(countryCode: string) {
 
 export async function transferCart(token?: string) {
   const cartId = await getCartId()
-  const authHeaders = token
-    ? { authorization: `Bearer ${token}` }
-    : await getAuthHeaders()
+  const options = await getStoreCartClientOptions()
+  const mergeOptions = token
+    ? { ...options, authorization: `Bearer ${token}` }
+    : options
 
   console.log("--- TransferCart Debug ---")
   console.log("Token provided:", !!token)
   console.log("Guest Cart ID:", cartId)
 
-  const publishableKey = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY
-  const backendUrl = process.env.MEDUSA_BACKEND_URL || process.env.NEXT_PUBLIC_MEDUSA_BACKEND_URL || "http://localhost:9000"
-
   try {
     console.log("Calling merge API (always)...")
-    
-    const response = await fetch(`${backendUrl}/store/carts/merge`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-publishable-api-key": publishableKey || "",
-        ...(authHeaders as any),
-      },
-      // Only include body if cartId exists
-      ...(cartId ? { body: JSON.stringify({ cart_id: cartId }) } : {}),
-      cache: "no-store",
-    })
 
-    if (response.ok) {
-      const data = await response.json()
+    const data = await medusaCartMerge(mergeOptions, cartId ?? undefined)
+
+    if (data) {
       console.log("--- Login Merge Response (JSON) ---")
       console.log(JSON.stringify(data, null, 2))
       console.log("-----------------------------------")
-      
+
       const activeCartId = data.cart?.id || data.id || data.cart_id
-      
-      if (activeCartId) {
+
+      if (activeCartId && typeof activeCartId === "string") {
         console.log("Storing Cart ID in cookie:", activeCartId)
         await setCartId(activeCartId)
       }
-    } else if (response.status === 404) {
-      // 404 is fine - it just means the customer has no active cart yet
-      console.log("No active cart found for this customer (expected).")
     } else {
-      const errorText = await response.text()
-      console.log(`Merge API Info (${response.status}):`, errorText)
-      if (cartId) {
-        await sdk.store.cart.transferCart(cartId, {}, authHeaders).catch(() => { })
-      }
+      console.log("No active cart found for this customer (expected).")
     }
-  } catch (error: any) {
-    console.error("Merge API error:", error.message)
+  } catch (error: unknown) {
+    console.error("Merge API error:", error instanceof Error ? error.message : error)
     if (cartId) {
-      await sdk.store.cart.transferCart(cartId, {}, authHeaders).catch(() => { })
+      await medusaCartTransfer(cartId, mergeOptions).catch(() => {})
     }
   }
 
@@ -298,42 +276,34 @@ export const addCustomerAddress = async (
     is_default_shipping: isDefaultShipping,
     metadata: {
       address_type: (formData.get("address_type") as string) || "HOME",
-    }
+    },
   }
 
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
+  try {
+    const options = await getStoreCartClientOptions()
+    await medusaCustomerCreateAddress(address, options)
 
-  return sdk.store.customer
-    .createAddress(address, {}, headers)
-    .then(async ({ customer }) => {
-      const customerCacheTag = await getCacheTag("customers")
-      revalidateTag(customerCacheTag)
-      return { success: true, error: null }
-    })
-    .catch((err) => {
-      return { success: false, error: err.toString() }
-    })
+    const customerCacheTag = await getCacheTag("customers")
+    revalidateTag(customerCacheTag)
+    return { success: true, error: null }
+  } catch (err) {
+    return { success: false, error: String(err) }
+  }
 }
 
 export const deleteCustomerAddress = async (
   addressId: string
 ): Promise<void> => {
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
+  try {
+    const options = await getStoreCartClientOptions()
+    await medusaCustomerDeleteAddress(addressId, options)
 
-  await sdk.store.customer
-    .deleteAddress(addressId, headers)
-    .then(async () => {
-      const customerCacheTag = await getCacheTag("customers")
-      revalidateTag(customerCacheTag)
-      return { success: true, error: null }
-    })
-    .catch((err) => {
-      return { success: false, error: err.toString() }
-    })
+    const customerCacheTag = await getCacheTag("customers")
+    revalidateTag(customerCacheTag)
+    return { success: true, error: null } as any
+  } catch (err) {
+    return { success: false, error: String(err) } as any
+  }
 }
 
 export const updateCustomerAddress = async (
@@ -359,7 +329,7 @@ export const updateCustomerAddress = async (
     country_code: formData.get("country_code") as string,
     metadata: {
       address_type: (formData.get("address_type") as string) || "HOME",
-    }
+    },
   } as any
 
   const phone = formData.get("phone") as string
@@ -368,42 +338,34 @@ export const updateCustomerAddress = async (
     address.phone = phone
   }
 
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
+  try {
+    const options = await getStoreCartClientOptions()
+    await medusaCustomerUpdateAddress(addressId, address, options)
 
-  return sdk.store.customer
-    .updateAddress(addressId, address, {}, headers)
-    .then(async () => {
-      const customerCacheTag = await getCacheTag("customers")
-      revalidateTag(customerCacheTag)
-      return { success: true, error: null }
-    })
-    .catch((err) => {
-      return { success: false, error: err.toString() }
-    })
+    const customerCacheTag = await getCacheTag("customers")
+    revalidateTag(customerCacheTag)
+    return { success: true, error: null }
+  } catch (err) {
+    return { success: false, error: String(err) }
+  }
 }
 
 export const setDefaultAddress = async (addressId: string) => {
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
+  try {
+    const options = await getStoreCartClientOptions()
+    await medusaCustomerUpdateAddress(addressId, { is_default_shipping: true }, options)
 
-  return sdk.store.customer
-    .updateAddress(addressId, { is_default_shipping: true }, {}, headers)
-    .then(async () => {
-      const customerCacheTag = await getCacheTag("customers")
-      revalidateTag(customerCacheTag)
-      return { success: true, error: null }
-    })
-    .catch((err) => {
-      return { success: false, error: err.toString() }
-    })
+    const customerCacheTag = await getCacheTag("customers")
+    revalidateTag(customerCacheTag)
+    return { success: true, error: null }
+  } catch (err) {
+    return { success: false, error: String(err) }
+  }
 }
 
 export async function initiateGoogleAuth() {
   try {
-    const backendUrl = process.env.MEDUSA_BACKEND_URL || process.env.NEXT_PUBLIC_MEDUSA_BACKEND_URL
+    const backendUrl = getMedusaBackendUrl()
 
     if (!backendUrl) {
       return { error: "Backend URL not configured" }
@@ -428,25 +390,19 @@ export async function initiateGoogleAuth() {
       return { error: "No redirect URL received from Google OAuth" }
     }
 
-    // Fix redirect URL: Remove country code prefix from callback URL if present
-    // Example: https://chocomelon.in/in/auth/customer/google/callback -> https://chocomelon.in/auth/customer/google/callback
     try {
       const url = new URL(redirectUrl)
-      const pathParts = url.pathname.split('/').filter(Boolean)
+      const pathParts = url.pathname.split("/").filter(Boolean)
 
-      // Check if path starts with country code pattern (2-3 letter code)
       if (pathParts.length > 0 && /^[a-z]{2,3}$/i.test(pathParts[0])) {
-        // Check if next part is 'auth'
-        if (pathParts.length > 1 && pathParts[1] === 'auth') {
-          // Remove country code from path
+        if (pathParts.length > 1 && pathParts[1] === "auth") {
           pathParts.shift()
-          url.pathname = '/' + pathParts.join('/')
+          url.pathname = "/" + pathParts.join("/")
           redirectUrl = url.toString()
         }
       }
     } catch (e) {
       // If URL parsing fails, use original redirectUrl
-
     }
 
     return { redirectUrl }
@@ -461,7 +417,7 @@ export async function handleGoogleAuthCallback(params: Record<string, string>) {
       return { error: "Missing authentication parameters" }
     }
 
-    const backendUrl = process.env.MEDUSA_BACKEND_URL || process.env.NEXT_PUBLIC_MEDUSA_BACKEND_URL
+    const backendUrl = getMedusaBackendUrl()
 
     if (!backendUrl) {
       return { error: "Backend URL not configured" }
@@ -502,23 +458,22 @@ export async function handleGoogleCallback(token: string, email?: string, first_
     }
 
     await setAuthToken(token)
-    await transferCart(token).catch(() => { })
+    await transferCart(token).catch(() => {})
 
     if (email && typeof email === "string") {
       const cookieStore = await cookies()
       cookieStore.set("_medusa_customer_email", email, { maxAge: 60 * 60 * 24 * 7, path: "/" })
 
-      const headers = await getAuthHeaders()
-      if (headers && "authorization" in headers) {
+      const options = await getStoreCartClientOptions()
+      if (options.authorization) {
         try {
-          await sdk.store.customer.create(
+          await medusaCustomerCreate(
             { email, ...(first_name && { first_name }), ...(last_name && { last_name }) },
-            {},
-            headers
+            options
           )
         } catch (err: any) {
           if (!err.message?.includes("already exists") && !err.message?.includes("duplicate")) {
-
+            // Ignore duplicate customer errors for OAuth sign-in
           }
         }
       }
@@ -541,7 +496,6 @@ export async function uploadProfileImage(formData: FormData) {
       return { error: "No image file provided" }
     }
 
-    // Create new FormData with 'files' field as expected by the backend
     const uploadFormData = new FormData()
     uploadFormData.append("files", imageFile)
 
@@ -557,7 +511,6 @@ export async function uploadProfileImage(formData: FormData) {
       throw new Error("No image URL returned from server")
     }
 
-    // Fetch current customer to preserve existing metadata
     const currentCustomer = await retrieveCustomer()
     const existingMetadata = (currentCustomer?.metadata as Record<string, any>) || {}
     const newMetadata = {
@@ -565,7 +518,6 @@ export async function uploadProfileImage(formData: FormData) {
       profile_image_url: imageUrl,
     }
 
-    // Update customer metadata
     await updateCustomer({ metadata: newMetadata })
 
     const customerCacheTag = await getCacheTag("customers")
@@ -575,7 +527,6 @@ export async function uploadProfileImage(formData: FormData) {
 
     return { success: true, imageUrl }
   } catch (error: any) {
-
     return { error: error.message || "Failed to upload image" }
   }
 }

package/src/server/dynamic-config.ts

@@ -260,7 +260,7 @@ export const getFeaturesFromConfig = async (): Promise<{ title: string; features
 
     if (!homepageConfig) return null
 
-    const title = homepageConfig["why-choose-us-title"] || "Why Choose Chocomelon?"
+    const title = homepageConfig["why-choose-us-title"] || "Why Choose Us?"
     const featuresRaw = homepageConfig["why-choose-us-features"] || []
 
     const features = featuresRaw.map((item: any) => {
@@ -293,7 +293,11 @@ export const getContactInfoFromConfig = async (): Promise<{ phone?: string; emai
 
     return {
       phone: contactConfig["contact-phone"],
-      email: contactConfig["contact-email"],
+      email:
+        typeof contactConfig["contact-email"] === "string" &&
+        /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(contactConfig["contact-email"].trim())
+          ? contactConfig["contact-email"].trim()
+          : undefined,
       address: contactConfig["contact-address"],
     }
   } catch (error) {