@kasuvia/sdk 0.0.2 → 0.0.5

package/src/hooks/use-service-booking.ts

@@ -1,118 +1,180 @@
 /**
  * Service Booking Hooks
- * 
+ *
  * React Query hooks for service bookings.
+ * config and accessToken are optional — if omitted, they are read from SdkContext.
  */
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { serviceBookingService } from '../services/service-booking.service'
+import {
+  getAvailableSlots,
+  bookAppointment,
+  getAppointments,
+  getAppointment,
+  cancelAppointment,
+  getDeliverables,
+  approveDeliverable,
+  requestRevision,
+} from '../services/service-booking.service'
+import type { SdkConfig } from '../config'
 import type {
-  ServiceAppointment,
   ServiceAppointmentCreatePayload,
-  ServiceDeliverable,
 } from '../types/services'
+import { logger } from '../utils'
+import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
 
-/**
- * Get available slots for a service product
- */
 export function useAvailableSlots(
-  product_id: string,
-  date_from: string,
-  date_to: string
+  arg1?: SdkConfig | string,
+  arg2?: string,
+  arg3?: string,
+  arg4?: string
 ) {
-  return useQuery({
-    queryKey: ["available-slots", product_id, date_from, date_to],
-    queryFn: () =>
-      serviceBookingService.getAvailableSlots(product_id, date_from, date_to),
-    enabled: !!product_id && !!date_from && !!date_to,
-  })
-}
-
-/**
- * Book a service appointment
- */
-export function useBookAppointment() {
-  const queryClient = useQueryClient()
+  const ctx = useSdkContext()
+  const isArg1Config = typeof arg1 === 'object' && arg1 !== null && 'businessId' in arg1
+  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined
+  const product_id = isArg1Config ? arg2 : (typeof arg1 === 'string' ? arg1 : undefined)
+  const date_from = isArg1Config ? arg3 : (typeof arg2 === 'string' ? arg2 : undefined)
+  const date_to = isArg1Config ? arg4 : (typeof arg3 === 'string' ? arg3 : undefined)
 
-  return useMutation({
-    mutationFn: serviceBookingService.bookAppointment,
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["appointments"] })
-    },
-  })
+  try {
+    const { config: cfg } = resolveHookArgs(explicitConfig, undefined, ctx)
+    return useQuery({
+      queryKey: ["available-slots", product_id, date_from, date_to],
+      queryFn: () => getAvailableSlots(cfg, product_id!, date_from!, date_to!),
+      enabled: !!product_id && !!date_from && !!date_to,
+    })
+  } catch (error) {
+    logger.warn('[useAvailableSlots] Called outside QueryClientProvider, returning undefined')
+    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
+  }
 }
 
-/**
- * Get all appointments for the current user
- */
-export function useAppointments() {
-  return useQuery({
-    queryKey: ["appointments"],
-    queryFn: serviceBookingService.getAppointments,
-  })
+export function useBookAppointment(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: ServiceAppointmentCreatePayload) =>
+        token ? bookAppointment(cfg, token, payload) : Promise.reject('No access token'),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["appointments"] })
+      },
+    })
+  } catch (error) {
+    logger.warn('[useBookAppointment] Called outside QueryClientProvider, returning no-op mutation')
+    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
+  }
 }
 
-/**
- * Get a single appointment by ID
- */
-export function useAppointment(id: string) {
-  return useQuery({
-    queryKey: ["appointment", id],
-    queryFn: () => serviceBookingService.getAppointment(id),
-    enabled: !!id,
-  })
+export function useAppointments(config?: SdkConfig, accessToken?: string | null) {
+  const ctx = useSdkContext()
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+    return useQuery({
+      queryKey: ["appointments"],
+      queryFn: () => token ? getAppointments(cfg, token) : Promise.resolve([]),
+      enabled: !!token,
+    })
+  } catch (error) {
+    logger.warn('[useAppointments] Called outside QueryClientProvider, returning empty list')
+    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
+  }
 }
 
-/**
- * Cancel an appointment
- */
-export function useCancelAppointment() {
-  const queryClient = useQueryClient()
+export function useAppointment(arg1?: SdkConfig | string, arg2?: string | null, arg3?: string) {
+  const ctx = useSdkContext()
+  const isArg1Config = typeof arg1 === 'object' && arg1 !== null && 'businessId' in arg1
+  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined
+  const explicitToken = isArg1Config ? (arg2 as string | null) : undefined
+  const id = isArg1Config ? arg3 : (typeof arg1 === 'string' ? arg1 : undefined)
 
-  return useMutation({
-    mutationFn: (id: string) => serviceBookingService.cancelAppointment(id),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["appointments"] })
-    },
-  })
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
+    return useQuery({
+      queryKey: ["appointment", id],
+      queryFn: () => token && id ? getAppointment(cfg, token, id) : Promise.resolve(undefined),
+      enabled: !!id && !!token,
+    })
+  } catch (error) {
+    logger.warn('[useAppointment] Called outside QueryClientProvider, returning undefined')
+    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
+  }
 }
 
-/**
- * Get deliverables for a project-based service order
- */
-export function useDeliverables(order_id: string) {
-  return useQuery({
-    queryKey: ["deliverables", order_id],
-    queryFn: () => serviceBookingService.getDeliverables(order_id),
-    enabled: !!order_id,
-  })
+export function useCancelAppointment(config?: SdkConfig, accessToken?: string | null) {
+  const ctx = useSdkContext()
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: (id: string) =>
+        token ? cancelAppointment(cfg, token, id) : Promise.reject('No access token'),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["appointments"] })
+      },
+    })
+  } catch (error) {
+    logger.warn('[useCancelAppointment] Called outside QueryClientProvider, returning no-op mutation')
+    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
+  }
 }
 
-/**
- * Approve a deliverable
- */
-export function useApproveDeliverable(order_id: string, deliverable_id: string) {
-  const queryClient = useQueryClient()
+export function useDeliverables(arg1?: SdkConfig | string, arg2?: string | null, arg3?: string) {
+  const ctx = useSdkContext()
+  const isArg1Config = typeof arg1 === 'object' && arg1 !== null && 'businessId' in arg1
+  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined
+  const explicitToken = isArg1Config ? (arg2 as string | null) : undefined
+  const order_id = isArg1Config ? arg3 : (typeof arg1 === 'string' ? arg1 : undefined)
 
-  return useMutation({
-    mutationFn: () =>
-      serviceBookingService.approveDeliverable(order_id, deliverable_id),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["deliverables", order_id] })
-    },
-  })
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
+    return useQuery({
+      queryKey: ["deliverables", order_id],
+      queryFn: () => token && order_id ? getDeliverables(cfg, token, order_id) : Promise.resolve([]),
+      enabled: !!order_id && !!token,
+    })
+  } catch (error) {
+    logger.warn('[useDeliverables] Called outside QueryClientProvider, returning empty list')
+    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
+  }
 }
 
-/**
- * Request revision for a deliverable
- */
-export function useRequestRevision(order_id: string, deliverable_id: string) {
-  const queryClient = useQueryClient()
+export function useApproveDeliverable(config?: SdkConfig, accessToken?: string | null, order_id?: string, deliverable_id?: string) {
+  const ctx = useSdkContext()
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: () =>
+        token && order_id && deliverable_id
+          ? approveDeliverable(cfg, token, order_id, deliverable_id)
+          : Promise.reject('No access token'),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["deliverables", order_id] })
+      },
+    })
+  } catch (error) {
+    logger.warn('[useApproveDeliverable] Called outside QueryClientProvider, returning no-op mutation')
+    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
+  }
+}
 
-  return useMutation({
-    mutationFn: (feedback: string) =>
-      serviceBookingService.requestRevision(order_id, deliverable_id, feedback),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["deliverables", order_id] })
-    },
-  })
+export function useRequestRevision(config?: SdkConfig, accessToken?: string | null, order_id?: string, deliverable_id?: string) {
+  const ctx = useSdkContext()
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: (feedback: string) =>
+        token && order_id && deliverable_id
+          ? requestRevision(cfg, token, order_id, deliverable_id, feedback)
+          : Promise.reject('No access token'),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["deliverables", order_id] })
+      },
+    })
+  } catch (error) {
+    logger.warn('[useRequestRevision] Called outside QueryClientProvider, returning no-op mutation')
+    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
+  }
 }

package/src/hooks/use-states.ts

@@ -2,27 +2,47 @@
  * States Hook
  * 
  * React Query hook for fetching states for a country.
+ * Stateless - requires config parameter.
  */
 import { useQuery } from '@tanstack/react-query'
-import { authAxios } from '../client/httpClient'
+import type { SdkConfig } from '../config'
 import type { State } from '../types/ui'
+import { logger } from '../utils'
+import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
 
-export async function getStates(countryIso: string): Promise<State[]> {
+export async function getStates(config: SdkConfig, countryIso: string): Promise<State[]> {
   if (!countryIso) return []
-  const { data } = await authAxios.get<State[]>('auth/countries/', {
-    params: { iso: countryIso }
+  const response = await fetch(`${config.backendUrls.auth}/auth/countries/?iso=${countryIso}`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
   })
-  return data
+  if (!response.ok) throw new Error('Failed to fetch states')
+  return response.json()
 }
 
-export function useStates(countryIso: string) {
-  return useQuery({
-    queryKey: ['states', countryIso],
-    queryFn: () => getStates(countryIso),
-    enabled: !!countryIso,
-    retry: 1,
-    refetchOnWindowFocus: false,
-    refetchOnReconnect: false,
-    staleTime: 24 * 60 * 60 * 1000, // 24 hours
-  })
+export function useStates(countryIso: string, config?: SdkConfig) {
+  const ctx = useSdkContext()
+  try {
+    const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+    return useQuery({
+      queryKey: ['states', countryIso],
+      queryFn: () => getStates(cfg, countryIso),
+      enabled: !!countryIso,
+      retry: 1,
+      refetchOnWindowFocus: false,
+      refetchOnReconnect: false,
+      staleTime: 24 * 60 * 60 * 1000,
+    })
+  } catch (error) {
+    logger.warn('[useStates] Called outside QueryClientProvider, returning empty list')
+    return {
+      data: [],
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: [] }),
+    } as any
+  }
 }

package/src/hooks/use-wishlist.ts

@@ -1,7 +1,8 @@
 /**
  * Wishlist Hooks
- * 
+ *
  * React Query hooks for wishlist operations.
+ * config and accessToken are optional — if omitted, they are read from SdkContext.
  */
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
 import {
@@ -11,7 +12,9 @@ import {
   removeProductFromWishlist,
   checkInWishlist,
 } from '../services/wishlist.service'
+import type { SdkConfig } from '../config'
 import { getCacheTier } from '../utils/cache'
+import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
 
 export const wishlistKeys = {
   all: ["wishlist"] as const,
@@ -19,103 +22,101 @@ export const wishlistKeys = {
   check: (productId: string) => [...wishlistKeys.all, "check", productId] as const,
 }
 
-/**
- * Hook for fetching the customer's wishlist.
- * Authentication-gated only - returns empty for unauthenticated users.
- */
-export function useWishlist(params?: { page?: number; pageSize?: number }) {
-  return useQuery({
-    queryKey: [...wishlistKeys.list(), params],
-    queryFn: () => getWishlist(params),
-    // medium — wishlist changes infrequently
-    ...getCacheTier('medium'),
-  })
-}
+export function useWishlist(arg1?: SdkConfig | { page?: number; pageSize?: number }, arg2?: string | null, arg3?: { page?: number; pageSize?: number }) {
+  const ctx = useSdkContext()
+  const isArg1Config = typeof arg1 === 'object' && arg1 !== null && 'businessId' in arg1
+  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined
+  const explicitToken = isArg1Config ? arg2 : undefined
+  const params = isArg1Config ? arg3 : (arg1 as { page?: number; pageSize?: number } | undefined)
 
-/**
- * Hook for checking if a product is in the wishlist.
- * Authentication-gated only - returns false for unauthenticated users.
- */
-export function useCheckInWishlist(productId: string) {
-  return useQuery({
-    queryKey: wishlistKeys.check(productId),
-    queryFn: () => checkInWishlist(productId),
-    // low — wishlist check changes frequently
-    ...getCacheTier('low'),
-    enabled: !!productId,
-  })
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
+    return useQuery({
+      queryKey: [...wishlistKeys.list(), params],
+      queryFn: () => token ? getWishlist(cfg, token, params) : Promise.resolve(undefined),
+      enabled: !!token,
+      ...getCacheTier('medium'),
+    })
+  } catch (error) {
+    console.warn('[useWishlist] Called outside QueryClientProvider, returning empty wishlist')
+    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
+  }
 }
 
-/**
- * Hook for adding a product to the wishlist.
- * Authentication-gated only - triggers login modal for unauthenticated users.
- */
-export function useAddToWishlist() {
-  const queryClient = useQueryClient()
-  
-  return useMutation({
-    mutationFn: ({ productId, notes }: { productId: string; notes?: string }) => {
-      return addToWishlist(productId, notes)
-    },
-    onSuccess: () => {
-      // Invalidate all wishlist queries to ensure cache is updated
-      queryClient.invalidateQueries({ queryKey: wishlistKeys.all })
-      // Also invalidate specific check queries for all products
-      queryClient.invalidateQueries({ queryKey: ['wishlist', 'check'] })
-    },
-  })
-}
+export function useCheckInWishlist(arg1?: SdkConfig | string, arg2?: string | null, arg3?: string) {
+  const ctx = useSdkContext()
+  const isArg1Config = typeof arg1 === 'object' && arg1 !== null && 'businessId' in arg1
+  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined
+  const explicitToken = isArg1Config ? (arg2 as string | null) : undefined
+  const productId = isArg1Config ? arg3 : (typeof arg1 === 'string' ? arg1 : undefined)
 
-/**
- * Hook for removing an item from the wishlist by item ID.
- */
-export function useRemoveFromWishlist() {
-  const queryClient = useQueryClient()
-  
-  return useMutation({
-    mutationFn: (itemId: string) => {
-      return removeFromWishlist(itemId)
-    },
-    onSuccess: () => {
-      // Invalidate all wishlist queries to ensure cache is updated
-      queryClient.invalidateQueries({ queryKey: wishlistKeys.all })
-      // Also invalidate specific check queries for all products
-      queryClient.invalidateQueries({ queryKey: ['wishlist', 'check'] })
-    },
-  })
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
+    return useQuery({
+      queryKey: wishlistKeys.check(productId ?? ''),
+      queryFn: () => token && productId ? checkInWishlist(cfg, token, productId) : Promise.resolve({ in_wishlist: false }),
+      ...getCacheTier('low'),
+      enabled: !!productId && !!token,
+    })
+  } catch (error) {
+    console.warn('[useCheckInWishlist] Called outside QueryClientProvider, returning false')
+    return { data: false, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: false }) } as any
+  }
 }
 
-/**
- * Hook for removing a product from the wishlist by product ID.
- */
-export function useRemoveProductFromWishlist() {
-  const queryClient = useQueryClient()
-  
-  return useMutation({
-    mutationFn: (productId: string) => {
-      return removeProductFromWishlist(productId)
-    },
-    onSuccess: () => {
-      // Invalidate all wishlist queries to ensure cache is updated
-      queryClient.invalidateQueries({ queryKey: wishlistKeys.all })
-      // Also invalidate specific check queries for all products
-      queryClient.invalidateQueries({ queryKey: ['wishlist', 'check'] })
-    },
-  })
+export function useAddToWishlist(config?: SdkConfig, accessToken?: string | null) {
+  const ctx = useSdkContext()
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: ({ productId, notes }: { productId: string; notes?: string }) =>
+        token ? addToWishlist(cfg, token, productId, notes) : Promise.reject('No access token'),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: wishlistKeys.all })
+        queryClient.invalidateQueries({ queryKey: ['wishlist', 'check'] })
+      },
+    })
+  } catch (error) {
+    console.warn('[useAddToWishlist] Called outside QueryClientProvider, returning no-op mutation')
+    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
+  }
 }
 
-/**
- * Hook for getting wishlist count.
- * Authentication-gated only - returns 0 for unauthenticated users.
- */
-export function useWishlistCount() {
-  const backendQuery = useQuery({
-    queryKey: wishlistKeys.list(),
-    queryFn: () => getWishlist(),
-    // low — wishlist count changes frequently
-    ...getCacheTier('low'),
-    select: (data) => data.total,
-  })
+export function useRemoveFromWishlist(config?: SdkConfig, accessToken?: string | null) {
+  const ctx = useSdkContext()
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: (itemId: string) =>
+        token ? removeFromWishlist(cfg, token, itemId) : Promise.reject('No access token'),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: wishlistKeys.all })
+        queryClient.invalidateQueries({ queryKey: ['wishlist', 'check'] })
+      },
+    })
+  } catch (error) {
+    console.warn('[useRemoveFromWishlist] Called outside QueryClientProvider, returning no-op mutation')
+    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
+  }
+}
 
-  return backendQuery
+export function useRemoveProductFromWishlist(config?: SdkConfig, accessToken?: string | null) {
+  const ctx = useSdkContext()
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: (productId: string) =>
+        token ? removeProductFromWishlist(cfg, token, productId) : Promise.reject('No access token'),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: wishlistKeys.all })
+        queryClient.invalidateQueries({ queryKey: ['wishlist', 'check'] })
+      },
+    })
+  } catch (error) {
+    console.warn('[useRemoveProductFromWishlist] Called outside QueryClientProvider, returning no-op mutation')
+    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
+  }
 }

package/src/index.ts

@@ -2,22 +2,29 @@
  * @kasuvia/sdk
  * 
  * Kasuvia SDK - Core data fetching, authentication, and API client layer
+ * Stateless architecture - no global state, all configuration passed as parameters.
  * 
  * @example
  * ```ts
- * import { initSdk, useCart, useOrders } from '@kasuvia/sdk'
+ * import { getStorefrontProductBySlug } from '@kasuvia/sdk'
+ * import { useCart, useAuth } from '@kasuvia/sdk/hooks'
+ * import type { SdkConfig } from '@kasuvia/sdk'
  * 
- * // Initialize SDK
- * initSdk({
+ * // Use in server components
+ * const config: SdkConfig = {
  *   businessId: 'B-123ABC',
  *   storefrontApiKey: 'your-api-key',
- *   environment: 'production'
- * })
- * 
- * // Configure HTTP clients after initialization
- * configureHttpClients()
+ *   backendUrls: {
+ *     auth: 'http://...',
+ *     store: 'http://...',
+ *     payment: 'http://...',
+ *     notifications: 'http://...',
+ *     cms: 'http://...',
+ *   }
+ * }
+ * const product = await getStorefrontProductBySlug(config, 'slug')
  * 
- * // Use in components
+ * // Use in client components
  * function Cart() {
  *   const { cart, addToCart } = useCart()
  *   // ...
@@ -26,33 +33,19 @@
  */
 
 // Configuration
-export { initSdk, getRuntimeConfig, getBackendUrl, isInitialized, resetConfig } from './config'
 export type { SdkConfig } from './config'
+export { SdkProvider, useSdkContext } from './context/sdk-context'
+export type { SdkContextValue, SdkProviderProps } from './context/sdk-context'
 
-// Client layer
-export { 
-  storeManagementAxios, 
-  publicStoreAxios, 
-  authAxios,
-  paymentAxios,
-  cmsAxios,
-  getOrCreateGuestSessionId,
-  getGuestSessionId,
-  clearGuestSessionId,
-  configureHttpClients,
-} from './client/httpClient'
-export { tokenStore, refreshToken } from './client/authClient'
-export { getGraphQLClient, resetGraphQLClient } from './client/graphqlClient'
+// Constants
+export { STORAGE_KEYS } from './constants'
 
 // Types
 export * from './types'
 
-// Services
+// Services (for server components)
 export * from './services'
 
-// React Hooks
-export * from './hooks'
-
 // Utils
 export { getCacheTier, setEnvironmentMode } from './utils/cache'
 export { logger, setLoggerEnvironmentMode } from './utils/logger'
@@ -61,8 +54,11 @@ export * from './utils/customer'
 export * from './utils/checkout'
 export * from './utils/error-handler'
 export { sessionStore, localStore } from './utils/storage'
-
-
+export * from './utils/validators'
 
 // App service functions
 export { googleTranslate } from './services/app.service'
+
+// Note: React hooks are exported separately via '@kasuvia/sdk/hooks' to avoid
+// importing them in server components. Use:
+// import { useCart, useAuth } from '@kasuvia/sdk/hooks'