medusa-storefront-data 1.0.0 → 2.0.0

package/src/server/categories.ts

@@ -1,41 +1,14 @@
-import { sdk } from "../config"
 import { HttpTypes } from "@medusajs/types"
-import { getCacheOptions } from "../cookies"
+import { medusaCategoryByHandle, medusaCategoryList } from "medusa-services/categories"
+import { getStoreClientOptions } from "../util/store-client"
 
 export const listCategories = async (query?: Record<string, any>) => {
   try {
-    const next = {
-      ...(await getCacheOptions("categories")),
-    }
-
-    const limit = query?.limit || 100
-
-    return sdk.client
-      .fetch<{ product_categories: HttpTypes.StoreProductCategory[] }>(
-        "/store/product-categories",
-        {
-          query: {
-            fields:
-              "*category_children, *products, *parent_category, *parent_category.parent_category",
-            limit,
-            ...query,
-          },
-          next: {
-            ...next,
-            revalidate: 0,
-          },
-          cache: "no-store",
-        }
-      )
-      .then(({ product_categories }) => product_categories)
-      .catch((error) => {
-        if (process.env.NODE_ENV === 'production' || process.env.CI) {
-          return []
-        }
-        throw error
-      })
-  } catch (error: any) {
-    if (process.env.NODE_ENV === 'production' || process.env.CI) {
+    const options = await getStoreClientOptions()
+    const { product_categories } = await medusaCategoryList(options, query)
+    return product_categories as unknown as HttpTypes.StoreProductCategory[]
+  } catch (error) {
+    if (process.env.NODE_ENV === "production" || process.env.CI) {
       return []
     }
     throw error
@@ -46,49 +19,23 @@ export const getCategoryByHandle = async (categoryHandle: string[]) => {
   try {
     const handle = `${categoryHandle.join("/")}`
     const decodedHandle = decodeURIComponent(handle)
+    const options = await getStoreClientOptions()
 
-
-    const next = {
-      ...(await getCacheOptions("categories")),
-    }
-
-    const result = await sdk.client
-      .fetch<HttpTypes.StoreProductCategoryListResponse>(
-        `/store/product-categories`,
-        {
-          query: {
-            handle: [decodedHandle],
-          },
-          next: {
-            ...next,
-            revalidate: 0,
-          },
-          cache: "no-store",
-        }
-      )
-
-    if (result.product_categories && result.product_categories.length > 0) {
-      return result.product_categories[0]
+    const matched = await medusaCategoryByHandle(decodedHandle, options)
+    if (matched) {
+      return matched as unknown as HttpTypes.StoreProductCategory
     }
 
-    // Fallback: Fetch all categories and find manually
-
-    const allCategories = await listCategories({ limit: "200" })
-    const matchedCategory = allCategories.find(c =>
-      c.handle === decodedHandle ||
-      c.handle === handle ||
-      c.handle?.replace(/-/g, " ") === decodedHandle
+    const allCategories = await listCategories({ limit: 200 })
+    const fallback = allCategories.find(
+      (c) =>
+        c.handle === decodedHandle ||
+        c.handle === handle ||
+        c.handle?.replace(/-/g, " ") === decodedHandle
     )
 
-    if (matchedCategory) {
-
-      return matchedCategory
-    }
-
-
-    return null
-  } catch (error: any) {
-
+    return fallback ?? null
+  } catch {
     return null
   }
 }

package/src/server/collections.ts

@@ -1,60 +1,28 @@
 "use server"
 
-import { sdk } from "../config"
 import { HttpTypes } from "@medusajs/types"
-import { getCacheOptions } from "../cookies"
+import {
+  medusaCollectionByHandle,
+  medusaCollectionList,
+  medusaCollectionRetrieve,
+} from "medusa-services/collections"
+import { getStoreClientOptions } from "../util/store-client"
 
 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)
+  const options = await getStoreClientOptions()
+  const { collection } = await medusaCollectionRetrieve(id, options)
+  return collection as unknown as HttpTypes.StoreCollection
 }
 
 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) {
+    const options = await getStoreClientOptions()
+    const { collections } = await medusaCollectionList(options, queryParams)
+    return { collections: collections as unknown as HttpTypes.StoreCollection[], count: collections.length }
+  } catch (error) {
+    if (process.env.NODE_ENV === "production" || process.env.CI) {
       return { collections: [], count: 0 }
     }
     throw error
@@ -65,49 +33,24 @@ export const getCollectionByHandle = async (
   handle: string
 ): Promise<HttpTypes.StoreCollection | null> => {
   try {
-    const next = {
-      ...(await getCacheOptions("collections")),
-    }
-
-    // Ensure handle is decoded
     const decodedHandle = decodeURIComponent(handle)
+    const options = await getStoreClientOptions()
 
-
-    // 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]
+    const matched = await medusaCollectionByHandle(decodedHandle, options)
+    if (matched) {
+      return matched as unknown as HttpTypes.StoreCollection
     }
 
-    // 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
+    const fallback = collections.find(
+      (c) =>
+        c.handle === decodedHandle ||
+        c.handle === handle ||
+        c.handle?.replace(/-/g, " ") === decodedHandle
     )
 
-    if (matchedCollection) {
-
-      return matchedCollection
-    }
-
-
-    return null
-  } catch (error: any) {
-
+    return fallback ?? null
+  } catch {
     return null
   }
 }

package/src/server/contact.ts

@@ -0,0 +1,92 @@
+"use server"
+
+import {
+  sendContactRequest,
+  subscribeToNewsletter as subscribeNewsletterApi,
+} from "medusa-services/contact-action"
+
+function getStoreConfig() {
+  const backendUrl =
+    process.env.MEDUSA_BACKEND_URL ||
+    process.env.NEXT_PUBLIC_MEDUSA_BACKEND_URL ||
+    "http://localhost:9000"
+  const publishableApiKey = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY || ""
+  return { backendUrl, publishableApiKey }
+}
+
+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, unknown>
+  source?: string
+}) {
+  try {
+    const { backendUrl, publishableApiKey } = getStoreConfig()
+    if (!publishableApiKey) {
+      return {
+        success: false as const,
+        error: "Configuration error: Publishable API key is missing.",
+      }
+    }
+
+    const data = await sendContactRequest({
+      backendUrl,
+      publishableKey: publishableApiKey,
+      data: { email, payload, metadata, source },
+    })
+
+    return { success: true as const, data }
+  } catch (error: unknown) {
+    const message =
+      error instanceof Error ? error.message : "Failed to submit contact request"
+    return { success: false as const, error: message }
+  }
+}
+
+export async function subscribeToNewsletter({
+  email,
+  status = "subscribed",
+  source = "footer",
+}: {
+  email: string
+  status?: "subscribed" | "unsubscribed"
+  source?: string
+}) {
+  try {
+    const { backendUrl, publishableApiKey } = getStoreConfig()
+    if (!publishableApiKey) {
+      return {
+        success: false as const,
+        message: "Server configuration error (missing key)",
+      }
+    }
+
+    const data = await subscribeNewsletterApi({
+      backendUrl,
+      publishableApiKey,
+      email,
+      status,
+      source,
+    })
+
+    return {
+      success: true as const,
+      message: "Thank you for subscribing!",
+      data,
+    }
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : "Something went wrong"
+    return { success: false as const, message }
+  }
+}