@kasuvia/sdk 0.0.8 → 0.0.9

package/src/hooks/use-cms.ts

@@ -3,6 +3,22 @@
  *
  * React Query hooks for CMS model and entry operations.
  * config and accessToken are optional — if omitted, they are read from SdkContext.
+ *
+ * REAL BUG FIXED (2026-09-21): every hook here called the service functions
+ * with only a BID, but kasuvia-cms's SDK routes require the business's
+ * internal UUID (see cms.service.ts's header comment) — resolved here via
+ * `useBusinessConfig()`. Also fixed `.entries`/`.total` → the real
+ * `.results`/`.count`/`.total_pages` response shape.
+ *
+ * REAL BUG FIXED (2026-09-22): every one of these five hooks wrapped
+ * useQuery/useMutation/useBusinessConfig in a try/catch that caught real
+ * setup failures (no SdkProvider/QueryClientProvider) and returned a
+ * fabricated "successful, empty" result instead (`entries: [], error:
+ * null`) — indistinguishable from "this CMS model genuinely has zero
+ * entries." Conditionally calling hooks inside a try block also risks
+ * breaking React's Rules of Hooks if the block throws partway through (the
+ * hook call count would differ between renders). No other hook in this SDK
+ * does this; removed to match.
  */
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
 import {
@@ -19,14 +35,15 @@ import type {
   UpdateCmsEntryParams,
   ListCmsEntriesParams,
 } from '../types/cms'
-import { logger } from '../utils'
 import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
+import { useBusinessConfig } from './use-business-config'
 
 export interface UseCmsEntriesReturn {
   entries: CmsEntry[]
   total: number
   page: number
   page_size: number
+  total_pages: number
   isLoading: boolean
   error: Error | null
   refetch: () => void
@@ -58,33 +75,24 @@ export function useCmsEntries(
     params = maybeParams
   }
 
-  try {
-    const query = useQuery({
-      queryKey: ['cms-entries', slug, params],
-      queryFn: () => listCmsEntries(cfg, slug, params),
-      enabled: !!slug,
-    })
-
-    return {
-      entries: query.data?.entries || [],
-      total: query.data?.total || 0,
-      page: query.data?.page || 1,
-      page_size: query.data?.page_size || 50,
-      isLoading: query.isLoading,
-      error: query.error as Error | null,
-      refetch: query.refetch,
-    }
-  } catch (error) {
-    logger.warn('[useCmsEntries] Called outside QueryClientProvider, returning empty list')
-    return {
-      entries: [],
-      total: 0,
-      page: 1,
-      page_size: 50,
-      isLoading: false,
-      error: null,
-      refetch: () => {},
-    }
+  const businessConfig = useBusinessConfig(cfg)
+  const businessUuid = businessConfig.data?.business_id
+
+  const query = useQuery({
+    queryKey: ['cms-entries', slug, params],
+    queryFn: () => listCmsEntries(cfg, businessUuid as string, slug, params),
+    enabled: !!slug && !!businessUuid,
+  })
+
+  return {
+    entries: query.data?.results || [],
+    total: query.data?.count || 0,
+    page: query.data?.page || 1,
+    page_size: query.data?.page_size || 50,
+    total_pages: query.data?.total_pages || 0,
+    isLoading: query.isLoading || businessConfig.isLoading,
+    error: (query.error || businessConfig.error) as Error | null,
+    refetch: query.refetch,
   }
 }
 
@@ -121,27 +129,20 @@ export function useCmsEntry(
     entryId = modelSlugOrEntryId
   }
 
-  try {
-    const query = useQuery({
-      queryKey: ['cms-entry', slug, entryId],
-      queryFn: () => getCmsEntry(cfg, slug, entryId),
-      enabled: !!slug && !!entryId,
-    })
+  const businessConfig = useBusinessConfig(cfg)
+  const businessUuid = businessConfig.data?.business_id
 
-    return {
-      entry: query.data,
-      isLoading: query.isLoading,
-      error: query.error as Error | null,
-      refetch: query.refetch,
-    }
-  } catch (error) {
-    logger.warn('[useCmsEntry] Called outside QueryClientProvider, returning undefined')
-    return {
-      entry: undefined,
-      isLoading: false,
-      error: null,
-      refetch: () => {},
-    }
+  const query = useQuery({
+    queryKey: ['cms-entry', slug, entryId],
+    queryFn: () => getCmsEntry(cfg, businessUuid as string, slug, entryId),
+    enabled: !!slug && !!entryId && !!businessUuid,
+  })
+
+  return {
+    entry: query.data,
+    isLoading: query.isLoading || businessConfig.isLoading,
+    error: (query.error || businessConfig.error) as Error | null,
+    refetch: query.refetch,
   }
 }
 
@@ -153,30 +154,23 @@ export interface UseCreateCmsEntryReturn {
 
 export function useCreateCmsEntry(config?: SdkConfig, accessToken?: string | null, modelSlug?: string): UseCreateCmsEntryReturn {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
-    const queryClient = useQueryClient()
-
-    const mutation = useMutation({
-      mutationFn: (params: CreateCmsEntryParams) =>
-        token && modelSlug ? createCmsEntry(cfg, token, modelSlug, params) : Promise.reject('No access token or modelSlug'),
-      onSuccess: () => {
-        if (modelSlug) queryClient.invalidateQueries({ queryKey: ['cms-entries', modelSlug] })
-      },
-    })
-
-    return {
-      createEntry: mutation.mutate,
-      isLoading: mutation.isPending,
-      error: mutation.error as Error | null,
-    }
-  } catch (error) {
-    logger.warn('[useCreateCmsEntry] Called outside QueryClientProvider, returning no-op mutation')
-    return {
-      createEntry: () => {},
-      isLoading: false,
-      error: null,
-    }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const businessConfig = useBusinessConfig(cfg)
+  const businessUuid = businessConfig.data?.business_id
+  const queryClient = useQueryClient()
+
+  const mutation = useMutation({
+    mutationFn: (params: CreateCmsEntryParams) =>
+      token && modelSlug && businessUuid ? createCmsEntry(cfg, businessUuid, token, modelSlug, params) : Promise.reject('No access token, modelSlug, or resolved business'),
+    onSuccess: () => {
+      if (modelSlug) queryClient.invalidateQueries({ queryKey: ['cms-entries', modelSlug] })
+    },
+  })
+
+  return {
+    createEntry: mutation.mutate,
+    isLoading: mutation.isPending,
+    error: mutation.error as Error | null,
   }
 }
 
@@ -188,34 +182,27 @@ export interface UseUpdateCmsEntryReturn {
 
 export function useUpdateCmsEntry(config?: SdkConfig, accessToken?: string | null, modelSlug?: string): UseUpdateCmsEntryReturn {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
-    const queryClient = useQueryClient()
-
-    const mutation = useMutation({
-      mutationFn: ({ entryId, params }: { entryId: string; params: UpdateCmsEntryParams }) =>
-        token && modelSlug ? updateCmsEntry(cfg, token, modelSlug, entryId, params) : Promise.reject('No access token or modelSlug'),
-      onSuccess: () => {
-        if (modelSlug) {
-          queryClient.invalidateQueries({ queryKey: ['cms-entries', modelSlug] })
-          queryClient.invalidateQueries({ queryKey: ['cms-entry', modelSlug] })
-        }
-      },
-    })
-
-    return {
-      updateEntry: (entryId: string, params: UpdateCmsEntryParams) =>
-        mutation.mutate({ entryId, params }),
-      isLoading: mutation.isPending,
-      error: mutation.error as Error | null,
-    }
-  } catch (error) {
-    logger.warn('[useUpdateCmsEntry] Called outside QueryClientProvider, returning no-op mutation')
-    return {
-      updateEntry: () => {},
-      isLoading: false,
-      error: null,
-    }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const businessConfig = useBusinessConfig(cfg)
+  const businessUuid = businessConfig.data?.business_id
+  const queryClient = useQueryClient()
+
+  const mutation = useMutation({
+    mutationFn: ({ entryId, params }: { entryId: string; params: UpdateCmsEntryParams }) =>
+      token && modelSlug && businessUuid ? updateCmsEntry(cfg, businessUuid, token, modelSlug, entryId, params) : Promise.reject('No access token, modelSlug, or resolved business'),
+    onSuccess: () => {
+      if (modelSlug) {
+        queryClient.invalidateQueries({ queryKey: ['cms-entries', modelSlug] })
+        queryClient.invalidateQueries({ queryKey: ['cms-entry', modelSlug] })
+      }
+    },
+  })
+
+  return {
+    updateEntry: (entryId: string, params: UpdateCmsEntryParams) =>
+      mutation.mutate({ entryId, params }),
+    isLoading: mutation.isPending,
+    error: mutation.error as Error | null,
   }
 }
 
@@ -227,32 +214,25 @@ export interface UseDeleteCmsEntryReturn {
 
 export function useDeleteCmsEntry(config?: SdkConfig, accessToken?: string | null, modelSlug?: string): UseDeleteCmsEntryReturn {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
-    const queryClient = useQueryClient()
-
-    const mutation = useMutation({
-      mutationFn: (entryId: string) =>
-        token && modelSlug ? deleteCmsEntry(cfg, token, modelSlug, entryId) : Promise.reject('No access token or modelSlug'),
-      onSuccess: () => {
-        if (modelSlug) {
-          queryClient.invalidateQueries({ queryKey: ['cms-entries', modelSlug] })
-          queryClient.invalidateQueries({ queryKey: ['cms-entry', modelSlug] })
-        }
-      },
-    })
-
-    return {
-      deleteEntry: mutation.mutate,
-      isLoading: mutation.isPending,
-      error: mutation.error as Error | null,
-    }
-  } catch (error) {
-    logger.warn('[useDeleteCmsEntry] Called outside QueryClientProvider, returning no-op mutation')
-    return {
-      deleteEntry: () => {},
-      isLoading: false,
-      error: null,
-    }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const businessConfig = useBusinessConfig(cfg)
+  const businessUuid = businessConfig.data?.business_id
+  const queryClient = useQueryClient()
+
+  const mutation = useMutation({
+    mutationFn: (entryId: string) =>
+      token && modelSlug && businessUuid ? deleteCmsEntry(cfg, businessUuid, token, modelSlug, entryId) : Promise.reject('No access token, modelSlug, or resolved business'),
+    onSuccess: () => {
+      if (modelSlug) {
+        queryClient.invalidateQueries({ queryKey: ['cms-entries', modelSlug] })
+        queryClient.invalidateQueries({ queryKey: ['cms-entry', modelSlug] })
+      }
+    },
+  })
+
+  return {
+    deleteEntry: mutation.mutate,
+    isLoading: mutation.isPending,
+    error: mutation.error as Error | null,
   }
 }

package/src/hooks/use-collections.ts

@@ -1,13 +1,27 @@
 /**
  * Collections Hooks
- * 
- * React Query hooks for fetching collections via Next.js API routes.
- * Client-side hooks fetch from API routes to avoid exposing backend URLs to browser.
+ *
+ * React Query hooks for fetching collections via the real GraphQL storefront API.
+ *
+ * REAL BUG FIXED (2026-09-22), live-confirmed: both hooks here fetched from
+ * `/api/collections` / `/api/collections/{slug}` — Next.js API routes that
+ * do not exist anywhere in kasuvia-storefront (`app/api/collections`
+ * confirmed absent). This is the exact same class of bug already found and
+ * fixed in use-products.ts ("every hook here used to fetch from a deleted
+ * Next.js API route") — this file was simply missed in that same pass. Two
+ * real, live consumers were affected: `app/collections/CollectionsClient.tsx`
+ * (the entire "browse all collections" page) and `HomeClient.tsx`'s four
+ * home-page collection rails — both have been silently 404ing on every
+ * real page load. Fixed the same way: call the SDK's real GraphQL service
+ * functions directly (collection.service.ts), resolving config from
+ * SdkContext the same way every other SDK hook does.
  */
 import { useQuery } from '@tanstack/react-query'
 import type { ListParams } from '../types/store'
 import { getCacheTier } from '../utils/cache'
-import { logger } from '../utils'
+import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
+import type { SdkConfig } from '../config'
+import { getStorefrontCollections, getStorefrontCollectionBySlug } from '../services/collection.service'
 
 export const collectionKeys = {
   all:   ['core', 'collections'] as const,
@@ -17,61 +31,27 @@ export const collectionKeys = {
 
 /**
  * Hook to fetch paginated collections for the storefront.
- * Fetches from Next.js API route to avoid exposing backend URLs.
  */
-export function useStorefrontCollections(params?: ListParams) {
-  try {
-    const queryParams = new URLSearchParams()
-    if (params?.page) queryParams.set('page', params.page.toString())
-    if (params?.pageSize) queryParams.set('pageSize', params.pageSize.toString())
-    
-    return useQuery({
-      queryKey: collectionKeys.list(params),
-      queryFn: async () => {
-        const response = await fetch(`/api/collections?${queryParams.toString()}`)
-        if (!response.ok) throw new Error('Failed to fetch collections')
-        return response.json()
-      },
-      // medium — collections change infrequently
-      ...getCacheTier('medium'),
-    })
-  } catch (error) {
-    logger.warn('[useStorefrontCollections] Called outside QueryClientProvider, returning empty list')
-    return {
-      data: undefined,
-      isLoading: false,
-      error: null,
-      isFetching: false,
-      refetch: () => Promise.resolve({ data: undefined }),
-    } as any
-  }
+export function useStorefrontCollections(params?: ListParams, config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: collectionKeys.list(params),
+    queryFn: () => getStorefrontCollections(cfg, params),
+    ...getCacheTier('medium'),
+  })
 }
 
 /**
  * Hook to fetch a single collection by slug for the storefront.
- * Fetches from Next.js API route to avoid exposing backend URLs.
  */
-export function useStorefrontCollection(slug: string) {
-  try {
-    return useQuery({
-      queryKey: collectionKeys.slug(slug),
-      queryFn: async () => {
-        const response = await fetch(`/api/collections/${slug}`)
-        if (!response.ok) throw new Error('Failed to fetch collection')
-        return response.json()
-      },
-      // medium — collection details change infrequently
-      ...getCacheTier('medium'),
-      enabled: !!slug,
-    })
-  } catch (error) {
-    logger.warn('[useStorefrontCollection] Called outside QueryClientProvider, returning undefined')
-    return {
-      data: undefined,
-      isLoading: false,
-      error: null,
-      isFetching: false,
-      refetch: () => Promise.resolve({ data: undefined }),
-    } as any
-  }
+export function useStorefrontCollection(slug: string, config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: collectionKeys.slug(slug),
+    queryFn: () => getStorefrontCollectionBySlug(cfg, slug),
+    ...getCacheTier('medium'),
+    enabled: !!slug,
+  })
 }

package/src/hooks/use-consultations.ts

@@ -1,145 +1,18 @@
 /**
- * Consultations Hooks
+ * Consultation Hooks
  *
- * React Query hooks for consultation operations.
- * config and accessToken are optional — if omitted, they are read from SdkContext.
+ * Create-only, by design — see consultation.service.ts's header comment.
  */
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import {
-  getConsultations,
-  getConsultation,
-  createConsultation,
-  sendMessage,
-  acceptQuote,
-  rejectQuote,
-} from '../services/consultation.service'
+import { useMutation } from '@tanstack/react-query'
+import { createConsultation, type CreateConsultationParams } from '../services/consultation.service'
 import type { SdkConfig } from '../config'
-import type {
-  ConsultationCreatePayload,
-  ConsultationMessagePayload,
-  ConsultationQuoteAcceptPayload,
-} from '../types/consultations'
-import { logger } from '../utils'
 import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
 
-export function useConsultations(config?: SdkConfig, accessToken?: string | null) {
-  const ctx = useSdkContext()
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
-    return useQuery({
-      queryKey: ['consultations'],
-      queryFn: () => token ? getConsultations(cfg, token) : Promise.resolve([]),
-      enabled: !!token,
-    })
-  } catch (error) {
-    logger.warn('[useConsultations] Called outside QueryClientProvider, returning empty list')
-    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
-  }
-}
-
-export function useConsultation(arg1?: SdkConfig | string, arg2?: string | null, arg3?: string) {
-  const ctx = useSdkContext()
-  const isArg1Config = typeof arg1 === 'object' && arg1 !== null
-  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined
-  const explicitToken = isArg1Config ? (arg2 as string | null) : undefined
-  const id = isArg1Config ? arg3 : (typeof arg1 === 'string' ? arg1 : undefined)
-
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
-    return useQuery({
-      queryKey: ['consultation', id],
-      queryFn: () => token && id ? getConsultation(cfg, token, id) : Promise.resolve(undefined),
-      enabled: !!id && !!token,
-    })
-  } catch (error) {
-    logger.warn('[useConsultation] Called outside QueryClientProvider, returning undefined')
-    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
-  }
-}
-
 export function useCreateConsultation(config?: SdkConfig, accessToken?: string | null) {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
-    const queryClient = useQueryClient()
-    return useMutation({
-      mutationFn: (payload: ConsultationCreatePayload) =>
-        token ? createConsultation(cfg, token, payload) : Promise.reject('No access token'),
-      onSuccess: () => {
-        queryClient.invalidateQueries({ queryKey: ['consultations'] })
-      },
-    })
-  } catch (error) {
-    logger.warn('[useCreateConsultation] Called outside QueryClientProvider, returning no-op mutation')
-    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
-  }
-}
-
-export function useSendMessage(arg1?: SdkConfig | string, arg2?: string | null, arg3?: string) {
-  const ctx = useSdkContext()
-  const isArg1Config = typeof arg1 === 'object' && arg1 !== null
-  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined
-  const explicitToken = isArg1Config ? (arg2 as string | null) : undefined
-  const consultationId = isArg1Config ? arg3 : (typeof arg1 === 'string' ? arg1 : undefined)
-
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
-    const queryClient = useQueryClient()
-    return useMutation({
-      mutationFn: (payload: ConsultationMessagePayload) =>
-        token && consultationId ? sendMessage(cfg, token, consultationId, payload) : Promise.reject('No access token'),
-      onSuccess: () => {
-        queryClient.invalidateQueries({ queryKey: ['consultation', consultationId] })
-      },
-    })
-  } catch (error) {
-    logger.warn('[useSendMessage] Called outside QueryClientProvider, returning no-op mutation')
-    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
-  }
-}
-
-export function useAcceptQuote(arg1?: SdkConfig | string, arg2?: string | null, arg3?: string) {
-  const ctx = useSdkContext()
-  const isArg1Config = typeof arg1 === 'object' && arg1 !== null
-  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined
-  const explicitToken = isArg1Config ? (arg2 as string | null) : undefined
-  const consultationId = isArg1Config ? arg3 : (typeof arg1 === 'string' ? arg1 : undefined)
-
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
-    const queryClient = useQueryClient()
-    return useMutation({
-      mutationFn: (payload: ConsultationQuoteAcceptPayload) =>
-        token && consultationId ? acceptQuote(cfg, token, consultationId, payload) : Promise.reject('No access token'),
-      onSuccess: () => {
-        queryClient.invalidateQueries({ queryKey: ['consultation', consultationId] })
-      },
-    })
-  } catch (error) {
-    logger.warn('[useAcceptQuote] Called outside QueryClientProvider, returning no-op mutation')
-    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
-  }
-}
-
-export function useRejectQuote(arg1?: SdkConfig | string, arg2?: string | null, arg3?: string) {
-  const ctx = useSdkContext()
-  const isArg1Config = typeof arg1 === 'object' && arg1 !== null
-  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined
-  const explicitToken = isArg1Config ? (arg2 as string | null) : undefined
-  const consultationId = isArg1Config ? arg3 : (typeof arg1 === 'string' ? arg1 : undefined)
-
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
-    const queryClient = useQueryClient()
-    return useMutation({
-      mutationFn: (reason?: string) =>
-        token && consultationId ? rejectQuote(cfg, token, consultationId, reason) : Promise.reject('No access token'),
-      onSuccess: () => {
-        queryClient.invalidateQueries({ queryKey: ['consultation', consultationId] })
-      },
-    })
-  } catch (error) {
-    logger.warn('[useRejectQuote] Called outside QueryClientProvider, returning no-op mutation')
-    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  return useMutation({
+    mutationFn: (params: CreateConsultationParams) =>
+      token ? createConsultation(cfg, token, params) : Promise.reject(new Error('Please sign in to submit a request.')),
+  })
 }

package/src/hooks/use-countries.ts

@@ -7,40 +7,31 @@
 import { useQuery } from '@tanstack/react-query'
 import type { SdkConfig } from '../config'
 import type { Country } from '../types/ui'
-import { logger } from '../utils'
 import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
+import { apiRequest, storefrontHeaders } from '../utils/http-client'
 
+/**
+ * REAL BUG FIXED (2026-09-22): raw fetch() with a generic `HTTP ${status}`
+ * error — this file predates apiRequest and was missed when every other
+ * REST call site in the SDK was migrated onto it (it lives in a hook file,
+ * not services/*.ts, which is how the original migration pass missed it).
+ */
 export async function getCountries(config: SdkConfig): Promise<Country[]> {
-  const response = await fetch(`${config.backendUrls.auth}/auth/countries/`, {
-    headers: {
-      "X-Storefront-Key": config.storefrontApiKey,
-      "X-Business-ID": config.businessId,
-    },
+  return apiRequest<Country[]>(`${config.backendUrls.auth}/auth/countries/`, {
+    headers: storefrontHeaders(config),
+    fallbackErrorMessage: 'Failed to fetch countries',
   })
-  if (!response.ok) throw new Error('Failed to fetch countries')
-  return response.json()
 }
 
 export function useCountries(config?: SdkConfig) {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg } = resolveHookArgs(config, undefined, ctx)
-    return useQuery({
-      queryKey: ['countries'],
-      queryFn: () => getCountries(cfg),
-      retry: 1,
-      refetchOnWindowFocus: false,
-      refetchOnReconnect: false,
-      staleTime: 24 * 60 * 60 * 1000,
-    })
-  } catch (error) {
-    logger.warn('[useCountries] Called outside QueryClientProvider, returning empty list')
-    return {
-      data: [],
-      isLoading: false,
-      error: null,
-      isFetching: false,
-      refetch: () => Promise.resolve({ data: [] }),
-    } as any
-  }
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: ['countries'],
+    queryFn: () => getCountries(cfg),
+    retry: 1,
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: false,
+    staleTime: 24 * 60 * 60 * 1000,
+  })
 }

package/src/hooks/use-currencies.ts

@@ -9,32 +9,20 @@ import { getCacheTier } from '../utils/cache'
 import { getSupportedCurrencies } from '../services/config.service'
 import type { SdkConfig } from '../config'
 import type { Currency } from '../types/payments'
-import { logger } from '../utils'
 import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
 
 export async function getSupportedCurrenciesList(config: SdkConfig): Promise<Currency[]> {
   const data = await getSupportedCurrencies(config)
-  return data.currencies || []
+  return (data.currencies || []).filter((currency: Currency) => currency.code !== 'auto')
 }
 
 export function useCurrencies(config?: SdkConfig) {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg } = resolveHookArgs(config, undefined, ctx)
-    return useQuery({
-      queryKey: ['supported-currencies'],
-      queryFn: () => getSupportedCurrenciesList(cfg),
-      retry: 1,
-      ...getCacheTier('high'),
-    })
-  } catch (error) {
-    logger.warn('[useCurrencies] Called outside QueryClientProvider, returning empty list')
-    return {
-      data: [],
-      isLoading: false,
-      error: null,
-      isFetching: false,
-      refetch: () => Promise.resolve({ data: [] }),
-    } as any
-  }
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: ['supported-currencies', cfg.businessId],
+    queryFn: () => getSupportedCurrenciesList(cfg),
+    retry: 1,
+    ...getCacheTier('high'),
+  })
 }