@kasuvia/sdk 0.0.2 → 0.0.4

package/src/hooks/use-cms.ts

@@ -2,6 +2,7 @@
  * CMS Hooks
  *
  * React Query hooks for CMS model and entry operations.
+ * config and accessToken are optional — if omitted, they are read from SdkContext.
  */
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
 import {
@@ -11,14 +12,15 @@ import {
   updateCmsEntry,
   deleteCmsEntry,
 } from '../services/cms.service'
-import { isInitialized } from '../config'
+import type { SdkConfig } from '../config'
 import type {
   CmsEntry,
-  CmsEntryListResponse,
   CreateCmsEntryParams,
   UpdateCmsEntryParams,
   ListCmsEntriesParams,
 } from '../types/cms'
+import { logger } from '../utils'
+import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
 
 export interface UseCmsEntriesReturn {
   entries: CmsEntry[]
@@ -32,25 +34,57 @@ export interface UseCmsEntriesReturn {
 
 /**
  * Hook to list CMS entries for a specific model.
+ * Signature can be:
+ *   useCmsEntries(config, modelSlug, params)
+ *   useCmsEntries(modelSlug, params)
  */
 export function useCmsEntries(
-  modelSlug: string,
-  params?: ListCmsEntriesParams
+  configOrModelSlug: SdkConfig | string,
+  modelSlugOrParams?: string | ListCmsEntriesParams,
+  maybeParams?: ListCmsEntriesParams
 ): UseCmsEntriesReturn {
-  const query = useQuery({
-    queryKey: ['cms-entries', modelSlug, params],
-    queryFn: () => listCmsEntries(modelSlug, params),
-    enabled: isInitialized() && !!modelSlug,
-  })
-
-  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,
+  const ctx = useSdkContext()
+  let cfg: SdkConfig
+  let slug: string
+  let params: ListCmsEntriesParams | undefined
+
+  if (typeof configOrModelSlug === 'string') {
+    slug = configOrModelSlug
+    params = modelSlugOrParams as ListCmsEntriesParams | undefined
+    cfg = resolveHookArgs(undefined, undefined, ctx).config
+  } else {
+    cfg = configOrModelSlug
+    slug = modelSlugOrParams as string
+    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: () => {},
+    }
   }
 }
 
@@ -63,22 +97,51 @@ export interface UseCmsEntryReturn {
 
 /**
  * Hook to get a single CMS entry by ID.
+ * Signature can be:
+ *   useCmsEntry(config, modelSlug, entryId)
+ *   useCmsEntry(modelSlug, entryId)
  */
 export function useCmsEntry(
-  modelSlug: string,
-  entryId: string
+  configOrModelSlug: SdkConfig | string,
+  modelSlugOrEntryId: string,
+  maybeEntryId?: string
 ): UseCmsEntryReturn {
-  const query = useQuery({
-    queryKey: ['cms-entry', modelSlug, entryId],
-    queryFn: () => getCmsEntry(modelSlug, entryId),
-    enabled: isInitialized() && !!modelSlug && !!entryId,
-  })
-
-  return {
-    entry: query.data,
-    isLoading: query.isLoading,
-    error: query.error as Error | null,
-    refetch: query.refetch,
+  const ctx = useSdkContext()
+  let cfg: SdkConfig
+  let slug: string
+  let entryId: string
+
+  if (maybeEntryId !== undefined) {
+    cfg = configOrModelSlug as SdkConfig
+    slug = modelSlugOrEntryId
+    entryId = maybeEntryId
+  } else {
+    cfg = resolveHookArgs(undefined, undefined, ctx).config
+    slug = configOrModelSlug as string
+    entryId = modelSlugOrEntryId
+  }
+
+  try {
+    const query = useQuery({
+      queryKey: ['cms-entry', slug, entryId],
+      queryFn: () => getCmsEntry(cfg, slug, entryId),
+      enabled: !!slug && !!entryId,
+    })
+
+    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: () => {},
+    }
   }
 }
 
@@ -88,23 +151,32 @@ export interface UseCreateCmsEntryReturn {
   error: Error | null
 }
 
-/**
- * Hook to create a new CMS entry.
- */
-export function useCreateCmsEntry(modelSlug: string): UseCreateCmsEntryReturn {
-  const queryClient = useQueryClient()
-
-  const mutation = useMutation({
-    mutationFn: (params: CreateCmsEntryParams) => createCmsEntry(modelSlug, params),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['cms-entries', modelSlug] })
-    },
-  })
-
-  return {
-    createEntry: mutation.mutate,
-    isLoading: mutation.isPending,
-    error: mutation.error as Error | null,
+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,
+    }
   }
 }
 
@@ -114,26 +186,36 @@ export interface UseUpdateCmsEntryReturn {
   error: Error | null
 }
 
-/**
- * Hook to update an existing CMS entry.
- */
-export function useUpdateCmsEntry(modelSlug: string): UseUpdateCmsEntryReturn {
-  const queryClient = useQueryClient()
-
-  const mutation = useMutation({
-    mutationFn: ({ entryId, params }: { entryId: string; params: UpdateCmsEntryParams }) =>
-      updateCmsEntry(modelSlug, entryId, params),
-    onSuccess: () => {
-      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,
+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,
+    }
   }
 }
 
@@ -143,23 +225,34 @@ export interface UseDeleteCmsEntryReturn {
   error: Error | null
 }
 
-/**
- * Hook to delete a CMS entry.
- */
-export function useDeleteCmsEntry(modelSlug: string): UseDeleteCmsEntryReturn {
-  const queryClient = useQueryClient()
-
-  const mutation = useMutation({
-    mutationFn: (entryId: string) => deleteCmsEntry(modelSlug, entryId),
-    onSuccess: () => {
-      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,
+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,
+    }
   }
 }

package/src/hooks/use-collections.ts

@@ -1,12 +1,13 @@
 /**
  * Collections Hooks
  * 
- * React Query hooks for fetching collections.
+ * 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.
  */
 import { useQuery } from '@tanstack/react-query'
-import { getStorefrontCollections, getStorefrontCollectionBySlug } from '../services/collection.service'
 import type { ListParams } from '../types/store'
 import { getCacheTier } from '../utils/cache'
+import { logger } from '../utils'
 
 export const collectionKeys = {
   all:   ['core', 'collections'] as const,
@@ -16,25 +17,61 @@ 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) {
-  return useQuery({
-    queryKey: collectionKeys.list(params),
-    queryFn: () => getStorefrontCollections(params),
-    // medium — collections change infrequently
-    ...getCacheTier('medium'),
-  })
+  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
+  }
 }
 
 /**
  * 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) {
-  return useQuery({
-    queryKey: collectionKeys.slug(slug),
-    queryFn: () => getStorefrontCollectionBySlug(slug),
-    // medium — collection details change infrequently
-    ...getCacheTier('medium'),
-    enabled: !!slug,
-  })
+  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
+  }
 }

package/src/hooks/use-consultation-stream.ts

@@ -2,7 +2,7 @@
 
 import { useEffect, useRef, useState } from 'react';
 import { fetchEventSource, EventSourceMessage } from '@microsoft/fetch-event-source';
-import { getBackendUrl } from '../config';
+import type { SdkConfig } from '../config';
 import { logger } from '../utils';
 
 interface ConsultationMessageData {
@@ -39,6 +39,7 @@ interface ConsultationStatusData {
 }
 
 interface UseConsultationStreamOptions {
+  config: SdkConfig;
   consultationId: string;
   onMessage?: (data: ConsultationMessageData) => void;
   onQuote?: (data: ConsultationQuoteData) => void;
@@ -47,6 +48,7 @@ interface UseConsultationStreamOptions {
 }
 
 export function useConsultationStream({
+  config,
   consultationId,
   onMessage,
   onQuote,
@@ -65,8 +67,7 @@ export function useConsultationStream({
     const abortController = new AbortController();
     abortControllerRef.current = abortController;
 
-    const paymentUrl = getBackendUrl('payment');
-    const streamUrl = `${paymentUrl}/events/stream/consultation/${consultationId}`;
+    const streamUrl = `${config.backendUrls.payment}/events/stream/consultation/${consultationId}`;
 
     fetchEventSource(streamUrl, {
       method: 'GET',

package/src/hooks/use-consultations.ts

@@ -1,76 +1,145 @@
 /**
  * Consultations Hooks
- * 
+ *
  * React Query hooks for consultation operations.
+ * config and accessToken are optional — if omitted, they are read from SdkContext.
  */
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { consultationService } from '../services/consultation.service'
+import {
+  getConsultations,
+  getConsultation,
+  createConsultation,
+  sendMessage,
+  acceptQuote,
+  rejectQuote,
+} from '../services/consultation.service'
+import type { SdkConfig } from '../config'
 import type {
-  Consultation,
   ConsultationCreatePayload,
   ConsultationMessagePayload,
   ConsultationQuoteAcceptPayload,
 } from '../types/consultations'
+import { logger } from '../utils'
+import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
 
-export function useConsultations() {
-  return useQuery({
-    queryKey: ['consultations'],
-    queryFn: () => consultationService.getConsultations(),
-  })
+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(id: string) {
-  return useQuery({
-    queryKey: ['consultation', id],
-    queryFn: () => consultationService.getConsultation(id),
-    enabled: !!id,
-  })
-}
+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)
 
-export function useCreateConsultation() {
-  const queryClient = useQueryClient()
+  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
+  }
+}
 
-  return useMutation({
-    mutationFn: (payload: ConsultationCreatePayload) =>
-      consultationService.createConsultation(payload),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['consultations'] })
-    },
-  })
+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(consultationId: string) {
-  const queryClient = useQueryClient()
+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)
 
-  return useMutation({
-    mutationFn: (payload: ConsultationMessagePayload) =>
-      consultationService.sendMessage(consultationId, payload),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['consultation', consultationId] })
-    },
-  })
+  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(consultationId: string) {
-  const queryClient = useQueryClient()
+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)
 
-  return useMutation({
-    mutationFn: (payload: ConsultationQuoteAcceptPayload) =>
-      consultationService.acceptQuote(consultationId, payload),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['consultation', consultationId] })
-    },
-  })
+  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(consultationId: string) {
-  const queryClient = useQueryClient()
+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)
 
-  return useMutation({
-    mutationFn: (reason?: string) =>
-      consultationService.rejectQuote(consultationId, reason),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['consultation', consultationId] })
-    },
-  })
+  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
+  }
 }