@kasuvia/sdk 0.0.2 → 0.0.4

package/src/hooks/use-auth.ts

@@ -1,182 +1,106 @@
 /**
- * Auth Hook & Context Provider
+ * Auth Hooks
  *
- * Provides customer authentication state and modal controls across the storefront.
+ * Stateless React Query hooks for authentication operations.
+ * The storefront should provide its own AuthProvider context that manages
+ * tokens and passes config to these hooks.
  */
-import React, { createContext, useContext, useState, useEffect, useCallback, type ReactNode } from 'react'
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { getAuthUser, loginCustomer, registerCustomer, updateProfile, logout as logoutService, silentRefresh } from '../services/auth.service'
-import { tokenStore } from '../client/authClient'
-import { resetGraphQLClient } from '../client/graphqlClient'
+import { getAuthUser, loginCustomer, registerCustomer, updateProfile, logout as logoutService } from '../services/auth.service'
 import { logger } from '../utils/logger'
 import type {
   CustomerLoginPayload,
   CustomerRegisterPayload,
   UpdateProfilePayload,
   CustomerUser,
-  AuthContextValue,
 } from '../types/auth'
-
-// ── React Context ────────────────────────────────────────────────────────────
-
-export const AuthCtx = React.createContext ? React.createContext<AuthContextValue | null>(null) : null
-
-export function AuthProvider({ children }: { children: ReactNode }) {
-  const [customer, setCustomer] = useState<CustomerUser | null>(null)
-  const [isLoading, setIsLoading] = useState(true)
-  const [isModalOpen, setIsModalOpen] = useState(false)
-
-  // Rehydrate session from stored refresh token on app boot
-  useEffect(() => {
-    let voided = false
-    ;(async () => {
-      setIsLoading(true)
-      try {
-        const result = await silentRefresh()
-        if (!voided && result) {
-          setCustomer(result.user)
-          resetGraphQLClient()
-        }
-      } catch (error: unknown) {
-        logger.error('[AuthProvider] Session restore failed:', error)
-        if (!voided) setCustomer(null)
-      } finally {
-        if (!voided) setIsLoading(false)
-      }
-    })()
-    return () => {
-      voided = true
-    }
-  }, [])
-
-  const openModal = useCallback(() => setIsModalOpen(true), [])
-  const closeModal = useCallback(() => {
-    setIsModalOpen(false)
-    if (typeof window !== 'undefined' && (window.location.hash === '#login' || window.location.hash === '#signup')) {
-      window.history.replaceState(null, '', window.location.pathname + window.location.search)
-    }
-  }, [])
-
-  // Listen for #login and #signup hashes to open modal automatically
-  useEffect(() => {
-    const handleHash = () => {
-      if (typeof window === 'undefined') return
-      if (window.location.hash === '#login' || window.location.hash === '#signup') {
-        if (!isLoading && customer) {
-          window.history.replaceState(null, '', window.location.pathname + window.location.search)
-        } else if (!isLoading && !customer) {
-          setIsModalOpen(true)
-        }
-      }
-    }
-    handleHash()
-    window.addEventListener('hashchange', handleHash)
-    return () => window.removeEventListener('hashchange', handleHash)
-  }, [customer, isLoading])
-
-  // Reset GraphQL client when customer state changes to ensure auth headers are included
-  useEffect(() => {
-    resetGraphQLClient()
-  }, [customer])
-
-  const handleLogout = useCallback(async () => {
-    await logoutService()
-    setCustomer(null)
-    setIsModalOpen(false)
-    resetGraphQLClient()
-  }, [])
-
-  const value: AuthContextValue = {
-    customer,
-    isLoading,
-    isModalOpen,
-    openModal,
-    closeModal,
-    setCustomer,
-    logout: handleLogout,
-  }
-
-  if (!AuthCtx) return children
-  return React.createElement(AuthCtx.Provider, { value }, children)
-}
+import type { SdkConfig } from '../config'
+import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
 
 // ── Hooks ────────────────────────────────────────────────────────────────────
 
-export function useAuthUser() {
-  return useQuery({
-    queryKey: ['auth-user'],
-    queryFn: getAuthUser,
-    enabled: !!tokenStore.getAccessToken(),
-  })
-}
-
-export function useLogin() {
-  const queryClient = useQueryClient()
-
-  return useMutation({
-    mutationFn: loginCustomer,
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['auth-user'] })
-      queryClient.invalidateQueries({ queryKey: ['cart'] })
-    },
-  })
+export function useAuthUser(config?: SdkConfig, accessToken?: string) {
+  const ctx = useSdkContext()
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken ?? null, ctx)
+    return useQuery({
+      queryKey: ['auth-user'],
+      queryFn: () => getAuthUser(cfg, token ?? ''),
+      enabled: !!token,
+    })
+  } catch (error) {
+    logger.warn('[useAuthUser] Called outside QueryClientProvider, returning empty user')
+    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
+  }
 }
 
-export function useRegister() {
-  const queryClient = useQueryClient()
-
-  return useMutation({
-    mutationFn: registerCustomer,
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['auth-user'] })
-      queryClient.invalidateQueries({ queryKey: ['cart'] })
-    },
-  })
+export function useLogin(config?: SdkConfig) {
+  const ctx = useSdkContext()
+  try {
+    const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: (payload: Omit<CustomerLoginPayload, 'tenant_id'>) => loginCustomer(cfg, payload),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ['auth-user'] })
+        queryClient.invalidateQueries({ queryKey: ['cart'] })
+      },
+    })
+  } catch (error) {
+    logger.warn('[useLogin] Called outside QueryClientProvider, returning no-op mutation')
+    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
+  }
 }
 
-export function useUpdateProfile() {
-  const queryClient = useQueryClient()
-
-  return useMutation({
-    mutationFn: updateProfile,
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['auth-user'] })
-    },
-  })
+export function useRegister(config?: SdkConfig) {
+  const ctx = useSdkContext()
+  try {
+    const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: (payload: Omit<CustomerRegisterPayload, 'tenant_id'>) => registerCustomer(cfg, payload),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ['auth-user'] })
+        queryClient.invalidateQueries({ queryKey: ['cart'] })
+      },
+    })
+  } catch (error) {
+    logger.warn('[useRegister] Called outside QueryClientProvider, returning no-op mutation')
+    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
+  }
 }
 
-export function useLogout() {
-  const queryClient = useQueryClient()
-
-  return useMutation({
-    mutationFn: logoutService,
-    onSuccess: () => {
-      queryClient.clear()
-    },
-  })
+export function useUpdateProfile(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: UpdateProfilePayload) =>
+        token ? updateProfile(cfg, token, payload) : Promise.reject('No access token'),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ['auth-user'] })
+      },
+    })
+  } catch (error) {
+    logger.warn('[useUpdateProfile] Called outside QueryClientProvider, returning no-op mutation')
+    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
+  }
 }
 
-/**
- * useAuth()
- * Consumes the AuthCtx provider value. Falls back to local hook query if no provider exists.
- */
-export function useAuth(): AuthContextValue {
-  const context = AuthCtx ? useContext(AuthCtx) : null
-  if (context) return context
-
-  // Fallback if useAuth is called outside AuthProvider (e.g. simple SSR/unit tests)
-  const authUserQuery = useAuthUser()
-  const logoutMutation = useLogout()
-
-  return {
-    customer: authUserQuery.data as CustomerUser | null,
-    isLoading: authUserQuery.isLoading,
-    isModalOpen: false,
-    openModal: () => {},
-    closeModal: () => {},
-    setCustomer: () => {},
-    logout: async () => {
-      await logoutMutation.mutateAsync()
-    },
+export function useLogout(config?: SdkConfig, refreshToken?: string) {
+  const ctx = useSdkContext()
+  try {
+    const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: () => logoutService(cfg, refreshToken),
+      onSuccess: () => {
+        queryClient.clear()
+      },
+    })
+  } catch (error) {
+    logger.warn('[useLogout] Called outside QueryClientProvider, returning no-op mutation')
+    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
   }
 }

package/src/hooks/use-bespoke-availability.ts

@@ -2,19 +2,36 @@
  * Bespoke Availability Hook
  * 
  * React Query hook for checking bespoke service availability.
+ * Stateless - requires config parameter.
  */
 import { useQuery } from '@tanstack/react-query'
-import { bespokeService } from '../services/bespoke.service'
+import { checkAvailability } from '../services/bespoke.service'
+import type { SdkConfig } from '../config'
 import type { BespokeAvailability } from '../types/consultations'
+import { logger } from '../utils'
+import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
 
 /**
  * Get bespoke availability for a product
  */
-export function useBespokeAvailability(product_id: string) {
-  return useQuery({
-    queryKey: ['bespoke-availability', product_id],
-    queryFn: () => bespokeService.checkAvailability(product_id),
-    enabled: !!product_id,
-    retry: false, // Don't retry if no config exists (returns 404)
-  })
+export function useBespokeAvailability(product_id: string, config?: SdkConfig) {
+  const ctx = useSdkContext()
+  try {
+    const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+    return useQuery({
+      queryKey: ['bespoke-availability', product_id],
+      queryFn: () => checkAvailability(cfg, product_id),
+      enabled: !!product_id,
+      retry: false,
+    })
+  } catch (error) {
+    logger.warn('[useBespokeAvailability] Called outside QueryClientProvider, returning undefined')
+    return {
+      data: undefined,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: undefined }),
+    } as any
+  }
 }