medusa-storefront-data 1.0.0 → 2.0.0

package/src/server/payment-details.ts

@@ -1,69 +1,41 @@
 "use server"
 
-import { sdk } from "../config"
-import { getAuthHeaders, getCacheOptions } from "../cookies"
+import {
+  medusaPaymentDetailCreate,
+  medusaPaymentDetailDelete,
+  medusaPaymentDetailMakeDefault,
+  medusaPaymentDetailsList,
+} from "medusa-services/payment"
+import { getStoreCartClientOptions } from "../util/store-client"
 
 export const listPaymentDetails = async () => {
-    const authHeaders = await getAuthHeaders()
-
-    // If no auth headers (guest user), don't even try to fetch
-    if (!authHeaders || Object.keys(authHeaders).length === 0) {
-        return []
-    }
-
-    const headers = {
-        ...authHeaders,
+  try {
+    const options = await getStoreCartClientOptions()
+    if (!options.authorization) {
+      return []
     }
 
-    const next = {
-        ...(await getCacheOptions("payment_details")),
-    }
-
-    return sdk.client
-        .fetch<any>(`/store/payment-details`, {
-            method: "GET",
-            headers,
-            next,
-            cache: "no-store",
-        })
-        .then((res: any) => res.payment_details || [])
-        .catch(() => [])
+    const { payment_details } = await medusaPaymentDetailsList(options)
+    return payment_details ?? []
+  } catch {
+    return []
+  }
 }
 
 export const createPaymentDetail = async (
-    type: "upi" | "bank" | "card",
-    detail_json: Record<string, string>
+  type: "upi" | "bank" | "card",
+  detail_json: Record<string, string>
 ) => {
-    const headers = {
-        ...(await getAuthHeaders()),
-    }
-
-    return sdk.client.fetch<any>(`/store/payment-details`, {
-        method: "POST",
-        headers,
-        body: { type, detail_json },
-    })
+  const options = await getStoreCartClientOptions()
+  return medusaPaymentDetailCreate(type, detail_json, options)
 }
 
 export const makeDefaultPaymentDetail = async (id: string) => {
-    const headers = {
-        ...(await getAuthHeaders()),
-    }
-
-    return sdk.client.fetch<any>(`/store/payment-details/${id}/make-default`, {
-        method: "POST",
-        headers,
-    })
+  const options = await getStoreCartClientOptions()
+  return medusaPaymentDetailMakeDefault(id, options)
 }
 
 export const deletePaymentDetail = async (id: string) => {
-    const headers = {
-        ...(await getAuthHeaders()),
-    }
-
-    return sdk.client.fetch<any>(`/store/payment-details/${id}`, {
-        method: "DELETE",
-        headers,
-    })
+  const options = await getStoreCartClientOptions()
+  return medusaPaymentDetailDelete(id, options)
 }
-

package/src/server/payment.ts

@@ -1,35 +1,15 @@
 "use server"
 
-import { sdk } from "../config"
-import { getAuthHeaders, getCacheOptions } from "../cookies"
 import { HttpTypes } from "@medusajs/types"
+import { medusaPaymentProvidersList } from "medusa-services/payment"
+import { getStoreCartClientOptions } from "../util/store-client"
 
 export const listCartPaymentMethods = async (regionId: string) => {
-  const headers = {
-    ...(await getAuthHeaders()),
+  try {
+    const options = await getStoreCartClientOptions()
+    const { payment_providers } = await medusaPaymentProvidersList(regionId, options)
+    return payment_providers.sort((a, b) => (a.id > b.id ? 1 : -1)) as HttpTypes.StorePaymentProvider[]
+  } catch {
+    return null
   }
-
-  const next = {
-    ...(await getCacheOptions("payment_providers")),
-  }
-
-  return sdk.client
-    .fetch<HttpTypes.StorePaymentProviderListResponse>(
-      `/store/payment-providers`,
-      {
-        method: "GET",
-        query: { region_id: regionId },
-        headers,
-        next,
-        cache: "no-store",
-      }
-    )
-    .then(({ payment_providers }) =>
-      payment_providers.sort((a, b) => {
-        return a.id > b.id ? 1 : -1
-      })
-    )
-    .catch(() => {
-      return null
-    })
 }

package/src/server/pincode.ts

@@ -0,0 +1,49 @@
+"use server"
+
+export type PincodeLookupResult = {
+  city: string
+  province: string
+}
+
+function titleCase(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/\b\w/g, (char) => char.toUpperCase())
+}
+
+/** Resolve Indian pincode to district (city) and state. */
+export async function lookupIndianPincode(
+  postalCode: string
+): Promise<PincodeLookupResult | null> {
+  const cleaned = postalCode.replace(/\D/g, "")
+  if (cleaned.length !== 6) return null
+
+  try {
+    const response = await fetch(
+      `https://postal-pincode-api.vercel.app/api/v1/pincode/${cleaned}`,
+      { next: { revalidate: 86400 } } as RequestInit
+    )
+    if (!response.ok) return null
+
+    const payload = await response.json()
+    const offices = payload?.data as Array<{
+      district?: string
+      state?: string
+      delivery?: boolean
+    }> | undefined
+
+    const match =
+      offices?.find((office) => office.delivery) ?? offices?.[0]
+
+    if (match?.district && match?.state) {
+      return {
+        city: titleCase(match.district),
+        province: titleCase(match.state),
+      }
+    }
+  } catch {
+    // ignore network errors
+  }
+
+  return null
+}

package/src/server/products.ts

@@ -1,11 +1,15 @@
 "use server"
 
-import { sdk } from "../config"
-import { sortProducts, type SortOptions } from "../util/sort-products"
+import { type SortOptions } from "../util/sort-products"
 import { HttpTypes } from "@medusajs/types"
-import { getAuthHeaders, getCacheOptions } from "../cookies"
 import { getRegion, retrieveRegion } from "./regions"
 import Color from "color"
+import {
+  medusaProductByHandle,
+  medusaProductHelperFilters,
+  medusaProductList,
+} from "medusa-services/products"
+import { getStoreClientOptions } from "../util/store-client"
 
 export const listProducts = async ({
   pageParam = 1,
@@ -22,24 +26,17 @@ export const listProducts = async ({
   nextPage: number | null
   queryParams?: HttpTypes.FindParams & HttpTypes.StoreProductListParams
 }> => {
-
-
   if (!countryCode && !regionId) {
-
     throw new Error("Country code or region ID is required")
   }
 
   const limit = queryParams?.limit || 12
-  const _pageParam = Math.max(pageParam, 1)
-  const offset = _pageParam === 1 ? 0 : (_pageParam - 1) * limit
 
   let region: HttpTypes.StoreRegion | undefined | null
 
   if (countryCode) {
-
     region = await getRegion(countryCode)
   } else {
-
     region = await retrieveRegion(regionId!)
   }
 
@@ -50,156 +47,24 @@ export const listProducts = async ({
     }
   }
 
-
-
-  const headers = {
-    ...(await getAuthHeaders()),
-  }
-
-  const next = {
-    ...(await getCacheOptions("products")),
-  }
-
-  // 1. Standard Medusa query parameters
-  const standardQuery: any = {
+  const options = await getStoreClientOptions()
+  const { products, count, nextPage } = await medusaProductList(options, {
+    pageParam,
     limit,
-    offset,
-    region_id: region?.id,
-    fields:
-      "*variants.calculated_price,+variants.inventory_quantity,*variants.images,+variants.metadata,+variants.options,+metadata,+tags,+average_rating,+total_rating_count,+total_rating_sum,",
-  }
-
-  // 2. Identify advanced filters that require the product-helper API
-  const advancedFilterKeys = [
-    "metadata", "min_price", "max_price", "q", "collection_id", "category_id",
-    "tags", "option_value", "gender", "color", "material", "style", "brand",
-    "type", "product_type", "order"
-  ]
-
-  const hasAdvancedFilters = !!(queryParams && Object.keys(queryParams).some(key =>
-    advancedFilterKeys.includes(key) && (queryParams as any)[key] !== undefined
-  ))
-
-  const endpoint = hasAdvancedFilters ? "/store/product-helper/products" : "/store/products";
-
-  let finalQuery: any = { ...standardQuery }
-
-  if (hasAdvancedFilters) {
-
-
-    // We use URLSearchParams to ensure correct formatting and handle repeated keys if needed
-    const params = new URLSearchParams()
-
-    // 1. Add standard params
-    params.append("limit", limit.toString())
-    params.append("offset", offset.toString())
-    if (region?.id) params.append("region_id", region.id)
-
-    // Use '*' for helper endpoint to let it resolve necessary relations
-    params.append("fields", "*")
-
-    // 2. Map queryParams
-    for (const [key, value] of Object.entries(queryParams || {})) {
-      if (["metadata", "min_price", "max_price", "limit", "offset", "region_id", "fields"].includes(key)) continue
-
-      const values = Array.isArray(value) ? value : [value]
-      const lowerKey = key.toLowerCase()
-
-      if (lowerKey === "color") {
-        // Map 'color' filter to 'option_value' which backend understands for variants
-        values.forEach(v => params.append("option_value[]", String(v)))
-      } else if (["material", "gender", "product_type", "type", "style", "brand"].includes(lowerKey)) {
-        // Map these to metadata as they are defined as metadata in your config
-        const metaKey = lowerKey === "type" ? "product_type" : lowerKey
-        values.forEach(v => params.append(`metadata[${metaKey}]`, String(v)))
-      } else {
-        // Standard mapping for others (tags, collection_id, etc.)
-        if (Array.isArray(value)) {
-          value.forEach(v => params.append(`${key}[]`, String(v)))
-        } else if (value !== undefined && value !== null) {
-          params.append(key, String(value))
-        }
-      }
-    }
-
-    // 3. Map price filters (min_price -> price_min, max_price -> price_max)
-    if ((queryParams as any).min_price) params.append("price_min", String((queryParams as any).min_price))
-    if ((queryParams as any).max_price) params.append("price_max", String((queryParams as any).max_price))
-
-    // 4. Map metadata filters to metadata[key] format
-    if ((queryParams as any).metadata) {
-      for (const [key, value] of Object.entries((queryParams as any).metadata)) {
-        const values = Array.isArray(value) ? value : [value]
-
-        values.forEach(v => {
-          if (key.toLowerCase() === "color") {
-            // Map color in metadata to option_value[]
-            params.append("option_value[]", String(v))
-          } else {
-            // Standard metadata format: metadata[key]=value
-            params.append(`metadata[${key}]`, String(v))
-          }
-        })
-      }
-    }
-
-    finalQuery = params
+    regionId: region.id,
+    queryParams: queryParams as Record<string, unknown> | undefined,
+  })
 
-  } else {
-    // Standard endpoint - only merge known safe Medusa keys from queryParams 
-    // to avoid "Unrecognized fields" errors
-    const safeKeys = ["order", "id", "handle", "status", "created_at", "updated_at", "type_id"]
-    for (const key of safeKeys) {
-      if (queryParams && (queryParams as any)[key]) {
-        finalQuery[key] = (queryParams as any)[key]
-      }
-    }
+  return {
+    response: {
+      products: products as unknown as HttpTypes.StoreProduct[],
+      count,
+    },
+    nextPage,
+    queryParams,
   }
-
-  // Use the appended query string to avoid SDK's default serialization issues with brackets
-  const requestUrl = hasAdvancedFilters ? `${endpoint}?${finalQuery.toString()}` : endpoint;
-
-  return sdk.client
-    .fetch<{ products: HttpTypes.StoreProduct[]; count: number }>(
-      requestUrl,
-      {
-        method: "GET",
-        query: hasAdvancedFilters ? undefined : finalQuery,
-        headers,
-        next: {
-          ...next,
-          revalidate: 0, // Disable Next.js cache for now to show logs
-        },
-        cache: "no-store", // Ensure it hits backend every time for testing
-      }
-    )
-    .then(({ products, count }) => {
-
-
-      const nextPage = count > offset + limit ? _pageParam + 1 : null
-
-      if (products && products.length > 0) {
-
-      }
-
-      return {
-        response: {
-          products: products || [],
-          count: count || 0,
-        },
-        nextPage: nextPage,
-        queryParams,
-      }
-    })
-    .catch((error) => {
-      throw error
-    })
 }
 
-/**
- * This will fetch 100 products to the Next.js cache and sort them based on the sortBy parameter.
- * It will then return the paginated products based on the page and limit parameters.
- */
 export const listProductsWithSort = async ({
   page = 1,
   queryParams,
@@ -217,10 +82,9 @@ export const listProductsWithSort = async ({
 }> => {
   const limit = queryParams?.limit || 12
 
-  // Directly fetch from backend with correct pagination
-  // This ensures the backend terminal logs the specific request
   const {
     response: { products, count },
+    nextPage,
   } = await listProducts({
     pageParam: page,
     queryParams: {
@@ -230,14 +94,9 @@ export const listProductsWithSort = async ({
     countryCode,
   })
 
-  // Sorting is now handled natively by the backend API via the 'order' query param.
-  const finalProducts = products
-
-  const nextPage = count > page * limit ? page + 1 : null
-
   return {
     response: {
-      products: finalProducts,
+      products,
       count,
     },
     nextPage,
@@ -245,9 +104,6 @@ export const listProductsWithSort = async ({
   }
 }
 
-/**
- * Fetch products that have a specific tag value
- */
 export async function getProductsByTag({
   tagValue,
   limit = 12,
@@ -259,7 +115,7 @@ export async function getProductsByTag({
 }) {
   try {
     const result = await listProducts({
-      queryParams: { tags: [tagValue], limit },
+      queryParams: { tags: [tagValue], limit } as HttpTypes.FindParams & HttpTypes.StoreProductListParams,
       countryCode,
     })
 
@@ -270,94 +126,81 @@ export async function getProductsByTag({
   }
 }
 
-/**
- * Fetch dynamic filter options from the backend API
- */
-export const getDynamicFilters = async (countryCode: string) => {
-  const backendUrl = process.env.MEDUSA_BACKEND_URL || "http://localhost:9000"
-  const publishableKey = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY
-
+export const getDynamicFilters = async (_countryCode: string) => {
   try {
-    if (!publishableKey) return { genders: [], productTypes: [], materials: [], colors: [] }
-
-    const response = await fetch(`${backendUrl}/store/product-helper/filters`, {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-        "x-publishable-api-key": publishableKey,
-      },
-      cache: "no-store",
-    })
-
-    if (!response.ok) {
+    const options = await getStoreClientOptions()
+    if (!options.publishableApiKey) {
       return { genders: [], productTypes: [], materials: [], colors: [] }
     }
 
-    const data = await response.json()
-    
+    const data = await medusaProductHelperFilters(options)
+
     const formatLabel = (str: string) => {
       return str
         .split(/[_-]/)
-        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-        .join(' ')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(" ")
     }
 
-    const metadata = data.metadata || {}
-    const variantOptions = data.variant_options || []
+    const metadata = (data.metadata as Record<string, string[]>) || {}
+    const variantOptions = (data.variant_options as Array<{ option_title: string; values?: string[] }>) || []
 
-    // Gather all unique colors from all possible sources
     const colorSet = new Set<string>()
-    
-    // 1. From variant options (check all options with title 'color')
-    variantOptions.forEach((o: any) => {
-      if (o.option_title.toLowerCase() === 'color' || o.option_title.toLowerCase() === 'colour') {
-        o.values?.forEach((v: string) => {
+
+    variantOptions.forEach((o) => {
+      if (o.option_title.toLowerCase() === "color" || o.option_title.toLowerCase() === "colour") {
+        o.values?.forEach((v) => {
           if (v) colorSet.add(v.trim().toLowerCase())
         })
       }
     })
 
-    // 2. From metadata colors (handle newline/comma separated values)
     if (metadata.color) {
-      metadata.color.forEach((c: string) => {
+      metadata.color.forEach((c) => {
         if (c) {
-          const parts = c.split(/[,/\n\r]+/).map(s => s.trim()).filter(Boolean)
-          parts.forEach(p => colorSet.add(p.toLowerCase()))
+          const parts = c
+            .split(/[,/\n\r]+/)
+            .map((s) => s.trim())
+            .filter(Boolean)
+          parts.forEach((p) => colorSet.add(p.toLowerCase()))
         }
       })
     }
 
     return {
-      genders: (metadata.gender || []).sort().map((g: string) => ({
+      genders: (metadata.gender || []).sort().map((g) => ({
         value: g,
-        label: formatLabel(g)
-      })),
-      productTypes: (data.product_types || []).sort((a: any, b: any) => a.label.localeCompare(b.label)).map((t: any) => ({
-        value: t.label,
-        label: formatLabel(t.label)
+        label: formatLabel(g),
       })),
-      materials: (metadata.material || []).sort().map((m: string) => ({
+      productTypes: ((data.product_types as Array<{ label: string }>) || [])
+        .sort((a, b) => a.label.localeCompare(b.label))
+        .map((t) => ({
+          value: t.label,
+          label: formatLabel(t.label),
+        })),
+      materials: (metadata.material || []).sort().map((m) => ({
         value: m,
-        label: formatLabel(m)
+        label: formatLabel(m),
       })),
-      colors: Array.from(colorSet).sort().map((c: string) => {
-        let hex = ""
-        try {
-          // Try to resolve color hex code using the Color library
-          hex = Color(c.replace(/\s+/g, '').toLowerCase()).hex()
-        } catch (e) {
+      colors: Array.from(colorSet)
+        .sort()
+        .map((c) => {
+          let hex = ""
           try {
-            hex = Color(c.toLowerCase()).hex()
-          } catch (e2) {
-            // No hex found
+            hex = Color(c.replace(/\s+/g, "").toLowerCase()).hex()
+          } catch {
+            try {
+              hex = Color(c.toLowerCase()).hex()
+            } catch {
+              // no hex
+            }
           }
-        }
-        return {
-          value: c,
-          label: formatLabel(c),
-          hex
-        }
-      })
+          return {
+            value: c,
+            label: formatLabel(c),
+            hex,
+          }
+        }),
     }
   } catch (error) {
     console.error("Error fetching dynamic filters:", error)
@@ -365,14 +208,8 @@ export const getDynamicFilters = async (countryCode: string) => {
   }
 }
 
-/**
- * Fetch a single product by its handle
- */
 export async function getProductByHandle(handle: string) {
-  const result = await sdk.store.product.list(
-    { handle, fields: "*variants.calculated_price,+variants.inventory_quantity,+variants.manage_inventory,+variants.allow_backorder,*variants.options,*options,*options.values,*images,*thumbnail,+metadata" },
-    { next: { tags: ["products"] } }
-  )
-  
-  return result.products[0]
+  const options = await getStoreClientOptions()
+  const product = await medusaProductByHandle(handle, options)
+  return product as unknown as HttpTypes.StoreProduct | undefined
 }

package/src/server/regions.ts

@@ -1,9 +1,12 @@
 "use server"
 
+import type { FetchArgs } from "@medusajs/js-sdk"
 import { sdk } from "../config"
 import medusaError from "../util/medusa-error"
 import { HttpTypes } from "@medusajs/types"
 import { getCacheOptions } from "../cookies"
+import { medusaRegionList } from "medusa-services/regions"
+import { getStoreCartClientOptions } from "../util/store-client"
 
 export const listRegions = async () => {
   const next = {
@@ -15,7 +18,7 @@ export const listRegions = async () => {
       method: "GET",
       next,
       cache: "force-cache",
-    })
+    } as FetchArgs & { next?: typeof next; cache?: RequestCache })
     .then(({ regions }) => regions)
     .catch(medusaError)
 }
@@ -30,7 +33,7 @@ export const retrieveRegion = async (id: string) => {
       method: "GET",
       next,
       cache: "force-cache",
-    })
+    } as FetchArgs & { next?: typeof next; cache?: RequestCache })
     .then(({ region }) => region)
     .catch(medusaError)
 }
@@ -43,15 +46,16 @@ export const getRegion = async (countryCode: string) => {
       return regionMap.get(countryCode)
     }
 
-    const regions = await listRegions()
+    const options = await getStoreCartClientOptions()
+    const { regions } = await medusaRegionList(options)
 
-    if (!regions) {
+    if (!regions?.length) {
       return null
     }
 
     regions.forEach((region) => {
       region.countries?.forEach((c) => {
-        regionMap.set(c?.iso_2 ?? "", region)
+        regionMap.set(c?.iso_2 ?? "", region as unknown as HttpTypes.StoreRegion)
       })
     })
 
@@ -59,7 +63,7 @@ export const getRegion = async (countryCode: string) => {
       ? regionMap.get(countryCode)
       : regionMap.get("us")
 
-    return region
+    return region ?? null
   } catch (e: any) {
     return null
   }