@kasuvia/sdk 0.0.8 → 0.0.9

package/src/services/cms.service.ts

@@ -1,9 +1,23 @@
 /**
  * CMS Service
- * 
+ *
  * Handles CMS model and entry operations using the kasuvia-cms SDK endpoints.
  * Protected by X-Storefront-Key and X-Business-ID headers.
  * Stateless - all configuration passed as parameters.
+ *
+ * REAL BUG FIXED (2026-09-21), live-reproduced: every URL here used
+ * `config.businessId` (the public BID, e.g. "B-2W9EC07") as the
+ * `{business_id}` path segment. kasuvia-cms's SDK routes
+ * (`app/core/security/base.py`'s `get_storefront_business_uuid`, used by
+ * every route in `cms_sdk.py`) explicitly require the INTERNAL UUID there —
+ * "CmsModel/CmsEntry documents are keyed by the UUID business_id... SDK
+ * routes need this, not the BID" (its own docstring) — and 403s with
+ * "Business ID mismatch" on anything else. Every CMS entry call from the
+ * storefront has been failing since the feature was built. Fixed by
+ * requiring an explicit `businessUuid` parameter (resolved via
+ * `getBusinessConfig`'s real `business_id` field, cached by
+ * `useBusinessConfig()` at the hook layer) instead of silently reusing the
+ * wrong config field.
  */
 import type { SdkConfig } from '../config'
 import type {
@@ -13,6 +27,7 @@ import type {
   UpdateCmsEntryParams,
   ListCmsEntriesParams,
 } from '../types/cms'
+import { apiRequest, storefrontHeaders, authHeaders, JSON_HEADERS } from '../utils/http-client'
 
 /**
  * List CMS entries for a specific model.
@@ -20,6 +35,7 @@ import type {
  */
 export async function listCmsEntries(
   config: SdkConfig,
+  businessUuid: string,
   modelSlug: string,
   params?: ListCmsEntriesParams
 ): Promise<CmsEntryListResponse> {
@@ -27,18 +43,13 @@ export async function listCmsEntries(
   queryParams.set('page', (params?.page || 1).toString())
   queryParams.set('page_size', (params?.page_size || 50).toString())
 
-  const response = await fetch(
-    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries?${queryParams.toString()}`,
+  return apiRequest<CmsEntryListResponse>(
+    `${config.backendUrls.cms}/sdk/${businessUuid}/${modelSlug}/entries?${queryParams.toString()}`,
     {
-      headers: {
-        "X-Storefront-Key": config.storefrontApiKey,
-        "X-Business-ID": config.businessId,
-      },
+      headers: storefrontHeaders(config),
+      fallbackErrorMessage: 'Failed to list CMS entries',
     }
   )
-
-  if (!response.ok) throw new Error('Failed to list CMS entries')
-  return response.json()
 }
 
 /**
@@ -47,21 +58,17 @@ export async function listCmsEntries(
  */
 export async function getCmsEntry(
   config: SdkConfig,
+  businessUuid: string,
   modelSlug: string,
   entryId: string
 ): Promise<CmsEntry> {
-  const response = await fetch(
-    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries/${entryId}`,
+  return apiRequest<CmsEntry>(
+    `${config.backendUrls.cms}/sdk/${businessUuid}/${modelSlug}/entries/${entryId}`,
     {
-      headers: {
-        "X-Storefront-Key": config.storefrontApiKey,
-        "X-Business-ID": config.businessId,
-      },
+      headers: storefrontHeaders(config),
+      fallbackErrorMessage: 'Failed to get CMS entry',
     }
   )
-
-  if (!response.ok) throw new Error('Failed to get CMS entry')
-  return response.json()
 }
 
 /**
@@ -70,26 +77,20 @@ export async function getCmsEntry(
  */
 export async function createCmsEntry(
   config: SdkConfig,
+  businessUuid: string,
   accessToken: string,
   modelSlug: string,
   params: CreateCmsEntryParams
 ): Promise<CmsEntry> {
-  const response = await fetch(
-    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries`,
+  return apiRequest<CmsEntry>(
+    `${config.backendUrls.cms}/sdk/${businessUuid}/${modelSlug}/entries`,
     {
       method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        "Authorization": `Bearer ${accessToken}`,
-        "X-Storefront-Key": config.storefrontApiKey,
-        "X-Business-ID": config.businessId,
-      },
+      headers: { ...JSON_HEADERS, ...authHeaders(config, accessToken) },
       body: JSON.stringify(params),
+      fallbackErrorMessage: 'Failed to create CMS entry',
     }
   )
-
-  if (!response.ok) throw new Error('Failed to create CMS entry')
-  return response.json()
 }
 
 /**
@@ -98,27 +99,21 @@ export async function createCmsEntry(
  */
 export async function updateCmsEntry(
   config: SdkConfig,
+  businessUuid: string,
   accessToken: string,
   modelSlug: string,
   entryId: string,
   params: UpdateCmsEntryParams
 ): Promise<CmsEntry> {
-  const response = await fetch(
-    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries/${entryId}`,
+  return apiRequest<CmsEntry>(
+    `${config.backendUrls.cms}/sdk/${businessUuid}/${modelSlug}/entries/${entryId}`,
     {
       method: 'PUT',
-      headers: {
-        'Content-Type': 'application/json',
-        "Authorization": `Bearer ${accessToken}`,
-        "X-Storefront-Key": config.storefrontApiKey,
-        "X-Business-ID": config.businessId,
-      },
+      headers: { ...JSON_HEADERS, ...authHeaders(config, accessToken) },
       body: JSON.stringify(params),
+      fallbackErrorMessage: 'Failed to update CMS entry',
     }
   )
-
-  if (!response.ok) throw new Error('Failed to update CMS entry')
-  return response.json()
 }
 
 /**
@@ -127,21 +122,17 @@ export async function updateCmsEntry(
  */
 export async function deleteCmsEntry(
   config: SdkConfig,
+  businessUuid: string,
   accessToken: string,
   modelSlug: string,
   entryId: string
 ): Promise<void> {
-  const response = await fetch(
-    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries/${entryId}`,
+  await apiRequest(
+    `${config.backendUrls.cms}/sdk/${businessUuid}/${modelSlug}/entries/${entryId}`,
     {
       method: 'DELETE',
-      headers: {
-        "Authorization": `Bearer ${accessToken}`,
-        "X-Storefront-Key": config.storefrontApiKey,
-        "X-Business-ID": config.businessId,
-      },
+      headers: authHeaders(config, accessToken),
+      fallbackErrorMessage: 'Failed to delete CMS entry',
     }
   )
-
-  if (!response.ok) throw new Error('Failed to delete CMS entry')
 }

package/src/services/collection.service.ts

@@ -1,68 +1,28 @@
 /**
  * Collection Service
- * 
+ *
  * Handles collection operations using GraphQL.
  * Stateless - all configuration passed as parameters.
  */
-import { GraphQLClient } from 'graphql-request'
 import type { Collection, PaginatedResponse, ListParams } from '../types/store'
 import type { SdkConfig } from '../config'
+import { createGraphQLClient } from '../utils/graphql-url'
+import {
+  GetStorefrontCollectionsDocument,
+  GetStorefrontCollectionBySlugDocument,
+  type CollectionFieldsFragment,
+} from '../generated/graphql'
 
-const GET_STOREFRONT_COLLECTIONS = `
-  query GetStorefrontCollections($page: Int!, $pageSize: Int!) {
-    storefront_collections(page: $page, pageSize: $pageSize) {
-      items {
-        id
-        business_id
-        name
-        slug
-        description
-        image 
-        collection_type
-        rules
-        status
-        sort_order
-        created_at
-        updated_at
-      }
-      total
-      page
-      page_size
-      total_pages
-    }
-  }
-`
-
-const GET_STOREFRONT_COLLECTION_BY_SLUG = `
-  query GetStorefrontCollectionBySlug($slug: String!) {
-    storefront_collection_by_slug(slug: $slug) {
-      id
-      business_id
-      name
-      slug
-      description
-      image 
-      collection_type
-      rules
-      status
-      sort_order
-      created_at
-      updated_at
-    }
-  }
-`
-
-/**
- * Create GraphQL client with provided config
- */
-function createGraphQLClient(config: SdkConfig): GraphQLClient {
-  const headers: Record<string, string> = {
-    'Content-Type': 'application/json',
-    'Accept': 'application/json',
-    'X-Storefront-Key': config.storefrontApiKey,
-    'X-Business-ID': config.businessId,
-  }
-  return new GraphQLClient(`${config.backendUrls.store}/graphql`, { headers })
+function mapCollection(raw: CollectionFieldsFragment): Collection {
+  return {
+    ...raw,
+    business_id: raw.business_id ?? undefined,
+    description: raw.description ?? undefined,
+    image_url: raw.image_url ?? undefined,
+    rules: raw.rules ?? undefined,
+    created_at: raw.created_at as string,
+    updated_at: raw.updated_at as string,
+  } satisfies Collection
 }
 
 /**
@@ -73,12 +33,11 @@ export async function getStorefrontCollections(
   params?: ListParams
 ): Promise<PaginatedResponse<Collection>> {
   const client = createGraphQLClient(config)
-  const variables = {
+  const data = await client.request(GetStorefrontCollectionsDocument, {
     page: params?.page || 1,
     pageSize: params?.pageSize || 20,
-  }
-  const data = await client.request(GET_STOREFRONT_COLLECTIONS, variables)
-  return data.storefront_collections
+  })
+  return { ...data.storefront_collections, items: data.storefront_collections.items.map(mapCollection) }
 }
 
 /**
@@ -89,6 +48,9 @@ export async function getStorefrontCollectionBySlug(
   slug: string
 ): Promise<Collection> {
   const client = createGraphQLClient(config)
-  const data = await client.request(GET_STOREFRONT_COLLECTION_BY_SLUG, { slug })
-  return data.storefront_collection_by_slug
+  const data = await client.request(GetStorefrontCollectionBySlugDocument, { slug })
+  if (!data.storefront_collection_by_slug) {
+    throw new Error(`Collection not found: ${slug}`)
+  }
+  return mapCollection(data.storefront_collection_by_slug)
 }

package/src/services/config.service.ts

@@ -7,20 +7,17 @@
 import type { SdkConfig } from '../config'
 import type { BackendLanguage, SupportedLanguagesResponse, SupportedCurrenciesResponse } from '../types/payments'
 import type { BusinessConfig } from '../types/business'
+import { apiRequest, storefrontHeaders } from '../utils/http-client'
 
 /**
  * Fetch supported languages from the payment system.
  * Resolves to: {kasuviaPaymentBackendUrl}/config/supported-languages
  */
 export async function getSupportedLanguages(config: SdkConfig): Promise<SupportedLanguagesResponse> {
-  const response = await fetch(`${config.backendUrls.payment}/config/supported-languages`, {
-    headers: {
-      "X-Storefront-Key": config.storefrontApiKey,
-      "X-Business-ID": config.businessId,
-    },
+  return apiRequest<SupportedLanguagesResponse>(`${config.backendUrls.payment}/config/supported-languages`, {
+    headers: storefrontHeaders(config),
+    fallbackErrorMessage: 'Failed to get supported languages',
   })
-  if (!response.ok) throw new Error('Failed to get supported languages')
-  return response.json()
 }
 
 /**
@@ -28,14 +25,10 @@ export async function getSupportedLanguages(config: SdkConfig): Promise<Supporte
  * Resolves to: {kasuviaPaymentBackendUrl}/config/supported-currencies
  */
 export async function getSupportedCurrencies(config: SdkConfig): Promise<SupportedCurrenciesResponse> {
-  const response = await fetch(`${config.backendUrls.payment}/config/supported-currencies`, {
-    headers: {
-      "X-Storefront-Key": config.storefrontApiKey,
-      "X-Business-ID": config.businessId,
-    },
+  return apiRequest<SupportedCurrenciesResponse>(`${config.backendUrls.payment}/config/supported-currencies`, {
+    headers: storefrontHeaders(config),
+    fallbackErrorMessage: 'Failed to get supported currencies',
   })
-  if (!response.ok) throw new Error('Failed to get supported currencies')
-  return response.json()
 }
 
 /**
@@ -45,14 +38,10 @@ export async function getSupportedCurrencies(config: SdkConfig): Promise<Support
  * This endpoint is designed for storefronts to fetch business config using their storefront API key.
  */
 export async function getBusinessConfig(config: SdkConfig): Promise<BusinessConfig> {
-  const response = await fetch(`${config.backendUrls.auth}/internal/businesses/${config.businessId}/`, {
-    headers: {
-      "X-Storefront-Key": config.storefrontApiKey,
-      "X-Business-ID": config.businessId,
-    },
+  return apiRequest<BusinessConfig>(`${config.backendUrls.auth}/internal/businesses/${config.businessId}/`, {
+    headers: storefrontHeaders(config),
+    fallbackErrorMessage: 'Failed to get business config',
   })
-  if (!response.ok) throw new Error('Failed to get business config')
-  return response.json()
 }
 
 export const configService = {

package/src/services/consultation.service.ts

@@ -1,105 +1,48 @@
 /**
  * Consultation Service
- * 
- * Handles consultation operations for bespoke and service products.
- * Stateless - all configuration passed as parameters.
+ *
+ * REAL BUG FIXED (2026-09-21): a "consultation" service existed earlier this
+ * session pointed at a fictional `/social/consultations/...` route that
+ * matched nothing in any backend — deleted along with its dead storefront
+ * pages. That deletion was correct (the URL was wrong), but a later audit
+ * of kasuvia-crm-go found the underlying feature is real:
+ * `POST /api/v1/consultations/` (customer-JWT-gated, real bespoke-slot-
+ * reservation side effect when product_id references a bespoke product).
+ * There is deliberately no list/get function here — kasuvia-crm-go's own
+ * code comment confirms "there is no customer-facing GET/list consultation
+ * endpoint at all" (admin_consultations.go). Create-only, by design.
  */
 import type { SdkConfig } from '../config'
-import type {
-  Consultation,
-  ConsultationCreatePayload,
-  ConsultationMessagePayload,
-  ConsultationQuoteAcceptPayload,
-} from '../types/consultations'
+import { apiRequest, authHeaders, JSON_HEADERS } from '../utils/http-client'
 
-export async function createConsultation(config: SdkConfig, accessToken: string, payload: ConsultationCreatePayload): Promise<Consultation> {
-  const response = await fetch(`${config.backendUrls.store}/social/consultations/`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      "Authorization": `Bearer ${accessToken}`,
-      "X-Storefront-Key": config.storefrontApiKey,
-      "X-Business-ID": config.businessId,
-    },
-    body: JSON.stringify(payload),
-  })
-  if (!response.ok) throw new Error('Failed to create consultation')
-  return response.json()
-}
-
-export async function getConsultations(config: SdkConfig, accessToken: string): Promise<Consultation[]> {
-  const response = await fetch(`${config.backendUrls.store}/social/consultations/`, {
-    headers: {
-      "Authorization": `Bearer ${accessToken}`,
-      "X-Storefront-Key": config.storefrontApiKey,
-      "X-Business-ID": config.businessId,
-    },
-  })
-  if (!response.ok) throw new Error('Failed to get consultations')
-  return response.json()
-}
-
-export async function getConsultation(config: SdkConfig, accessToken: string, id: string): Promise<Consultation> {
-  const response = await fetch(`${config.backendUrls.store}/social/consultations/${id}`, {
-    headers: {
-      "Authorization": `Bearer ${accessToken}`,
-      "X-Storefront-Key": config.storefrontApiKey,
-      "X-Business-ID": config.businessId,
-    },
-  })
-  if (!response.ok) throw new Error('Failed to get consultation')
-  return response.json()
+export interface CreateConsultationParams {
+  product_id?: string
+  structured_details?: Record<string, unknown>
 }
 
-export async function sendMessage(config: SdkConfig, accessToken: string, id: string, payload: ConsultationMessagePayload): Promise<void> {
-  await fetch(`${config.backendUrls.store}/social/consultations/${id}/messages`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      "Authorization": `Bearer ${accessToken}`,
-      "X-Storefront-Key": config.storefrontApiKey,
-      "X-Business-ID": config.businessId,
-    },
-    body: JSON.stringify(payload),
-  })
-}
-
-export async function acceptQuote(config: SdkConfig, accessToken: string, id: string, payload: ConsultationQuoteAcceptPayload): Promise<Consultation> {
-  const response = await fetch(`${config.backendUrls.store}/social/consultations/${id}/accept-quote`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      "Authorization": `Bearer ${accessToken}`,
-      "X-Storefront-Key": config.storefrontApiKey,
-      "X-Business-ID": config.businessId,
-    },
-    body: JSON.stringify(payload),
-  })
-  if (!response.ok) throw new Error('Failed to accept quote')
-  return response.json()
+export interface Consultation {
+  id: string
+  business_id: string
+  customer_id: string | null
+  product_id: string | null
+  status: string
+  quote_amount: number | null
+  structured_details: Record<string, unknown>
+  capacity_config_id: string | null
+  slot_booking_id: string | null
+  created_at: string
+  updated_at: string
 }
 
-export async function rejectQuote(config: SdkConfig, accessToken: string, id: string, reason?: string): Promise<Consultation> {
-  const response = await fetch(`${config.backendUrls.store}/social/consultations/${id}/reject-quote`, {
+export async function createConsultation(
+  config: SdkConfig,
+  accessToken: string,
+  params: CreateConsultationParams
+): Promise<Consultation> {
+  return apiRequest<Consultation>(`${config.backendUrls.crm}/consultations/`, {
     method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      "Authorization": `Bearer ${accessToken}`,
-      "X-Storefront-Key": config.storefrontApiKey,
-      "X-Business-ID": config.businessId,
-    },
-    body: JSON.stringify({ reason }),
+    headers: { ...JSON_HEADERS, ...authHeaders(config, accessToken) },
+    body: JSON.stringify(params),
+    fallbackErrorMessage: 'Failed to submit your request',
   })
-  if (!response.ok) throw new Error('Failed to reject quote')
-  return response.json()
-}
-
-// Service object export for backward compatibility
-export const consultationService = {
-  createConsultation,
-  getConsultations,
-  getConsultation,
-  sendMessage,
-  acceptQuote,
-  rejectQuote,
 }

package/src/services/feedback.service.ts

@@ -0,0 +1,76 @@
+/**
+ * Feedback Service
+ *
+ * REAL FEATURE WIRED (2026-09-21): kasuvia-crm-go's feedback.go (`POST
+ * /api/v1/feedback/`, `GET /api/v1/feedback/my`) is a complete, real,
+ * customer-JWT-gated support-ticket system — private business<->customer
+ * correspondence, distinct from a public, purchase-verified product Review —
+ * with zero SDK coverage anywhere before this file.
+ */
+import type { SdkConfig } from '../config'
+import { apiRequest, authHeaders, JSON_HEADERS } from '../utils/http-client'
+
+/** Mirrors kasuvia-crm-go's models.ValidFeedbackCategories exactly. */
+export type FeedbackCategory = 'general' | 'complaint' | 'suggestion'
+
+/** Mirrors kasuvia-crm-go's models.ValidFeedbackStatuses exactly. */
+export type FeedbackStatus = 'open' | 'in_progress' | 'resolved'
+
+export interface CreateFeedbackParams {
+  subject: string
+  body: string
+  /** Defaults to 'general' server-side if omitted. */
+  category?: FeedbackCategory
+  order_id?: string
+}
+
+export interface Feedback {
+  id: string
+  business_id: string
+  customer_id: string
+  order_id: string | null
+  category: FeedbackCategory
+  subject: string
+  body: string
+  status: FeedbackStatus
+  merchant_reply: string | null
+  merchant_reply_at: string | null
+  replied_by: string | null
+  created_at: string
+  updated_at: string
+}
+
+export interface FeedbackListResponse {
+  results: Feedback[]
+  count: number
+  page: number
+  page_size: number
+  total_pages: number
+}
+
+export async function createFeedback(
+  config: SdkConfig,
+  accessToken: string,
+  params: CreateFeedbackParams
+): Promise<Feedback> {
+  return apiRequest<Feedback>(`${config.backendUrls.crm}/feedback/`, {
+    method: 'POST',
+    headers: { ...JSON_HEADERS, ...authHeaders(config, accessToken) },
+    body: JSON.stringify(params),
+    fallbackErrorMessage: 'Failed to submit your message',
+  })
+}
+
+export async function getMyFeedback(
+  config: SdkConfig,
+  accessToken: string,
+  params?: { page?: number; page_size?: number }
+): Promise<FeedbackListResponse> {
+  const query = new URLSearchParams()
+  if (params?.page) query.set('page', String(params.page))
+  if (params?.page_size) query.set('page_size', String(params.page_size))
+  return apiRequest<FeedbackListResponse>(`${config.backendUrls.crm}/feedback/my?${query.toString()}`, {
+    headers: authHeaders(config, accessToken),
+    fallbackErrorMessage: 'Failed to load your requests',
+  })
+}

package/src/services/index.ts

@@ -6,12 +6,13 @@
 
 export * from './cart.service'
 export * from './order.service'
+export * from './consultation.service'
+export * from './feedback.service'
 export * from './auth.service'
 export * from './product.service'
 export * from './collection.service'
 export * from './wishlist.service'
 export * from './payment.service'
-export * from './consultation.service'
 export * from './logistics.service'
 export * from './bespoke.service'
 export * from './service-booking.service'
@@ -19,3 +20,8 @@ export * from './notifications.service'
 export * from './app.service'
 export * from './config.service'
 export * from './cms.service'
+export * from './legal.service'
+export * from './review.service'
+export * from './media.service'
+
+

package/src/services/legal.service.ts

@@ -0,0 +1,62 @@
+/**
+ * Legal Service
+ *
+ * Fetches this business's own currently-active storefront legal document
+ * (Terms, Privacy, or Refund Policy) from kasuvia-cms — public, no auth,
+ * the same endpoint the registration flow's consent record is checked against
+ * (see kasuvia-auth's CustomerTermsAcceptance).
+ *
+ * website-builder-system auto-generates storefront_terms/storefront_privacy
+ * the first time a business publishes (_ensure_storefront_legal_documents).
+ * A business that hasn't published yet, or whose auto-generation failed,
+ * genuinely has none yet. Returns null in that case rather than throwing;
+ * the page decides how to render that honestly — never substituting placeholder
+ * text for real legal text.
+ */
+import type { SdkConfig } from '../config';
+import type { MerchantLegalDocument } from '../types/cms/legal';
+
+export type { MerchantLegalDocument };
+export type { LegalSection } from '../types/cms/legal';
+
+/**
+ * Fetch a storefront legal document from kasuvia-cms.
+ *
+ * REAL BUG FIXED (2026-09-22): took a raw `cmsBaseUrl` string instead of
+ * `SdkConfig` — the only function across this SDK's ~90 service functions
+ * that broke that convention, which is exactly why kasuvia-storefront's
+ * `lib/legal.ts` wrapper existed at all (bridging this one odd signature
+ * back to the app's real config). `businessUuid` is kept as its own
+ * explicit parameter rather than silently reading `config.businessId`:
+ * this real backend route (`GET /cms/legal/storefront/{business_id}/...`,
+ * confirmed against kasuvia-cms's `get_business_id` dependency and
+ * `MerchantLegalDocument.business_id` field) is keyed by the internal
+ * business UUID, never the public BID `config.businessId` actually is —
+ * the same UUID-vs-BID class of bug already found and fixed in
+ * `cms.service.ts`. Resolve it the same way (`useBusinessConfig`'s real
+ * `business_id` field) before calling this.
+ *
+ * @param config - SdkConfig; only `backendUrls.cms` is read from it here.
+ * @param businessUuid - The tenant's real business UUID (not the public BID).
+ * @param documentType - e.g. "storefront_terms", "storefront_privacy",
+ *                       "storefront_refund_policy"
+ * @param fetchOptions - Optional native fetch options (e.g. Next.js `next: { revalidate }`)
+ */
+export async function getMerchantLegalDocument(
+  config: SdkConfig,
+  businessUuid: string,
+  documentType: string,
+  fetchOptions?: RequestInit,
+): Promise<MerchantLegalDocument | null> {
+  if (!businessUuid || !config?.backendUrls?.cms) return null;
+  try {
+    const res = await fetch(
+      `${config.backendUrls.cms}/cms/legal/storefront/${businessUuid}/${documentType}`,
+      fetchOptions,
+    );
+    if (!res.ok) return null;
+    return (await res.json()) as MerchantLegalDocument;
+  } catch {
+    return null;
+  }
+}