@kasuvia/sdk 0.0.2 → 0.0.4

package/src/hooks/use-payment.ts

@@ -1,68 +1,136 @@
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { paymentService } from "../services/payment.service";
-import { getCacheTier } from "../utils/cache";
-import { isInitialized } from "../config";
+import { createDedicatedAccount, initiatePayment, verifyTransaction, getTransactionStatus } from "../services/payment.service";
+import type { SdkConfig } from "../config";
 import type { DVACreateRequest, PaymentInitiateRequest } from "../types/payments";
-
+import { logger } from "../utils";
+import { useSdkContext, resolveHookArgs } from "../context/sdk-context";
 
 /**
  * Hook for creating a Dedicated Virtual Account (DVA)
+ * Optional config and accessToken — read from SdkContext if omitted.
  */
-export function useCreateDVA() {
-  const queryClient = useQueryClient();
+export function useCreateDVA(config?: SdkConfig, accessToken?: string | null) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient();
 
-  return useMutation({
-    mutationFn: (request: DVACreateRequest) =>
-      paymentService.createDedicatedAccount(request),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['payment'] });
-    },
-  });
+    return useMutation({
+      mutationFn: (request: DVACreateRequest) =>
+        token ? createDedicatedAccount(cfg, token, request) : Promise.reject('No access token'),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ['payment'] });
+      },
+    });
+  } catch (error) {
+    logger.warn('[useCreateDVA] Called outside QueryClientProvider, returning no-op mutation');
+    return {
+      mutate: () => {},
+      mutateAsync: () => Promise.resolve(undefined),
+    } as any;
+  }
 }
 
 /**
  * Hook for initiating card payment
+ * Optional config and accessToken — read from SdkContext if omitted.
  */
-export function useInitiatePayment() {
-  return useMutation({
-    mutationFn: (request: PaymentInitiateRequest) =>
-      paymentService.initiatePayment(request),
-  });
+export function useInitiatePayment(config?: SdkConfig, accessToken?: string | null) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    return useMutation({
+      mutationFn: (request: PaymentInitiateRequest) =>
+        token ? initiatePayment(cfg, token, request) : Promise.reject('No access token'),
+    });
+  } catch (error) {
+    logger.warn('[useInitiatePayment] Called outside QueryClientProvider, returning no-op mutation');
+    return {
+      mutate: () => {},
+      mutateAsync: () => Promise.resolve(undefined),
+    } as any;
+  }
 }
 
 /**
  * Hook for verifying a transaction
+ * Optional config — read from SdkContext if omitted.
  */
-export function useVerifyTransaction() {
-  return useMutation({
-    mutationFn: (reference: string) =>
-      paymentService.verifyTransaction(reference),
-  });
+export function useVerifyTransaction(config?: SdkConfig) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg } = resolveHookArgs(config, undefined, ctx);
+    return useMutation({
+      mutationFn: (reference: string) => verifyTransaction(cfg, reference),
+    });
+  } catch (error) {
+    logger.warn('[useVerifyTransaction] Called outside QueryClientProvider, returning no-op mutation');
+    return {
+      mutate: () => {},
+      mutateAsync: () => Promise.resolve(undefined),
+    } as any;
+  }
 }
 
 /**
  * Hook for getting transaction status
+ * Optional config — read from SdkContext if omitted.
  */
-export function useTransactionStatus(transactionId: string, enabled = false) {
-  return useQuery({
-    queryKey: ['transaction', 'status', transactionId],
-    queryFn: () => paymentService.getTransactionStatus(transactionId),
-    enabled: isInitialized() && enabled,
-    ...getCacheTier('none'),
-    refetchInterval: 3000, // Poll every 3 seconds
-  });
+export function useTransactionStatus(arg1?: SdkConfig | string, arg2?: string | boolean, arg3?: boolean) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === 'object' && arg1 !== null && 'businessId' in arg1;
+  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined;
+  const transactionId = isArg1Config ? (arg2 as string) : (typeof arg1 === 'string' ? arg1 : '');
+  const enabled = isArg1Config ? (arg3 ?? false) : (typeof arg2 === 'boolean' ? arg2 : false);
+
+  try {
+    const { config: cfg } = resolveHookArgs(explicitConfig, undefined, ctx);
+    return useQuery({
+      queryKey: ['transaction', 'status', transactionId],
+      queryFn: () => getTransactionStatus(cfg, transactionId),
+      enabled: enabled && !!transactionId,
+      refetchInterval: 3000,
+    });
+  } catch (error) {
+    logger.warn('[useTransactionStatus] Called outside QueryClientProvider, returning undefined');
+    return {
+      data: undefined,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: undefined }),
+    } as any;
+  }
 }
 
 /**
  * Hook for checking transaction status with automatic polling
+ * Optional config — read from SdkContext if omitted.
  */
-export function usePollTransactionStatus(reference: string, enabled = false) {
-  return useQuery({
-    queryKey: ['transaction', 'poll', reference],
-    queryFn: () => paymentService.verifyTransaction(reference),
-    enabled: isInitialized() && enabled,
-    ...getCacheTier('none'),
-    refetchInterval: 2000, // Poll every 2 seconds
-    retry: 10, // Retry up to 10 times
-  });
+export function usePollTransactionStatus(arg1?: SdkConfig | string, arg2?: string | boolean, arg3?: boolean) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === 'object' && arg1 !== null && 'businessId' in arg1;
+  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined;
+  const reference = isArg1Config ? (arg2 as string) : (typeof arg1 === 'string' ? arg1 : '');
+  const enabled = isArg1Config ? (arg3 ?? false) : (typeof arg2 === 'boolean' ? arg2 : false);
+
+  try {
+    const { config: cfg } = resolveHookArgs(explicitConfig, undefined, ctx);
+    return useQuery({
+      queryKey: ['transaction', 'poll', reference],
+      queryFn: () => verifyTransaction(cfg, reference),
+      enabled: enabled && !!reference,
+      refetchInterval: 2000,
+      retry: 10,
+    });
+  } catch (error) {
+    logger.warn('[usePollTransactionStatus] 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-products.ts

@@ -1,20 +1,13 @@
 /**
  * Products Hooks
  * 
- * React Query hooks for fetching products.
+ * React Query hooks for fetching products 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 {
-  getStorefrontProducts,
-  getLatestProducts,
-  getPopularProducts,
-  getFeaturedProducts,
-  getNewProducts,
-  getStorefrontProductBySlug,
-  getRecommendedProducts
-} from '../services/product.service'
 import type { ListParams } from '../types/store'
 import { getCacheTier } from '../utils/cache'
+import { logger } from '../utils'
 
 export const productKeys = {
   all: ["products"] as const,
@@ -25,89 +18,294 @@ export const productKeys = {
   popular: (params?: ListParams) => [...productKeys.all, "popular", params] as const,
   featured: (params?: ListParams) => [...productKeys.all, "featured", params] as const,
   new: (params?: ListParams) => [...productKeys.all, "new", params] as const,
+  onSale: (params?: ListParams) => [...productKeys.all, "onSale", params] as const,
+  lowStock: (params?: ListParams) => [...productKeys.all, "lowStock", params] as const,
 }
 
 /**
  * Hook for fetching latest products.
+ * Fetches from Next.js API route to avoid exposing backend URLs.
  */
 export function useLatestProducts(params?: ListParams) {
-  return useQuery({
-    queryKey: productKeys.latest(params),
-    queryFn: () => getLatestProducts(params),
-    // medium — latest products 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: productKeys.latest(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/latest?${queryParams.toString()}`)
+        if (!response.ok) throw new Error('Failed to fetch latest products')
+        return response.json()
+      },
+      // medium — latest products change infrequently
+      ...getCacheTier('medium'),
+    })
+  } catch (error) {
+    logger.warn('[useLatestProducts] Called outside QueryClientProvider, returning empty list')
+    return {
+      data: undefined,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: undefined }),
+    } as any
+  }
 }
 
 /**
  * Hook for fetching popular products.
+ * Fetches from Next.js API route to avoid exposing backend URLs.
  */
 export function usePopularProducts(params?: ListParams) {
-  return useQuery({
-    queryKey: productKeys.popular(params),
-    queryFn: () => getPopularProducts(params),
-    // medium — popular products 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: productKeys.popular(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/popular?${queryParams.toString()}`)
+        if (!response.ok) throw new Error('Failed to fetch popular products')
+        return response.json()
+      },
+      // medium — popular products change infrequently
+      ...getCacheTier('medium'),
+    })
+  } catch (error) {
+    logger.warn('[usePopularProducts] Called outside QueryClientProvider, returning empty list')
+    return {
+      data: undefined,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: undefined }),
+    } as any
+  }
 }
 
 /**
  * Hook for fetching featured products.
+ * Fetches from Next.js API route to avoid exposing backend URLs.
  */
 export function useFeaturedProducts(params?: ListParams) {
-  return useQuery({
-    queryKey: productKeys.featured(params),
-    queryFn: () => getFeaturedProducts(params),
-    // medium — featured products 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: productKeys.featured(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/featured?${queryParams.toString()}`)
+        if (!response.ok) throw new Error('Failed to fetch featured products')
+        return response.json()
+      },
+      // medium — featured products change infrequently
+      ...getCacheTier('medium'),
+    })
+  } catch (error) {
+    logger.warn('[useFeaturedProducts] Called outside QueryClientProvider, returning empty list')
+    return {
+      data: undefined,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: undefined }),
+    } as any
+  }
 }
 
 /**
  * Hook for fetching new products.
+ * Fetches from Next.js API route to avoid exposing backend URLs.
  */
 export function useNewProducts(params?: ListParams) {
-  return useQuery({
-    queryKey: productKeys.new(params),
-    queryFn: () => getNewProducts(params),
-    // medium — new products 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: productKeys.new(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/new?${queryParams.toString()}`)
+        if (!response.ok) throw new Error('Failed to fetch new products')
+        return response.json()
+      },
+      // medium — new products change infrequently
+      ...getCacheTier('medium'),
+    })
+  } catch (error) {
+    logger.warn('[useNewProducts] Called outside QueryClientProvider, returning empty list')
+    return {
+      data: undefined,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: undefined }),
+    } as any
+  }
+}
+
+/**
+ * Hook for fetching products currently on sale.
+ * Fetches from Next.js API route to avoid exposing backend URLs.
+ */
+export function useOnSaleProducts(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: productKeys.onSale(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/on-sale?${queryParams.toString()}`)
+        if (!response.ok) throw new Error('Failed to fetch on-sale products')
+        return response.json()
+      },
+      // medium — sale products change infrequently
+      ...getCacheTier('medium'),
+    })
+  } catch (error) {
+    logger.warn('[useOnSaleProducts] Called outside QueryClientProvider, returning empty list')
+    return {
+      data: undefined,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: undefined }),
+    } as any
+  }
+}
+
+/**
+ * Hook for fetching products with low stock.
+ * Fetches from Next.js API route to avoid exposing backend URLs.
+ */
+export function useLowStockProducts(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: productKeys.lowStock(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/low-stock?${queryParams.toString()}`)
+        if (!response.ok) throw new Error('Failed to fetch low-stock products')
+        return response.json()
+      },
+      // low — low stock status changes frequently
+      ...getCacheTier('low'),
+    })
+  } catch (error) {
+    logger.warn('[useLowStockProducts] Called outside QueryClientProvider, returning empty list')
+    return {
+      data: undefined,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: undefined }),
+    } as any
+  }
 }
 
 /**
  * Hook for fetching all active storefront products.
+ * Fetches from Next.js API route to avoid exposing backend URLs.
  */
 export function useStorefrontProducts(params?: ListParams) {
-  return useQuery({
-    queryKey: productKeys.list(params),
-    queryFn: () => getStorefrontProducts(params),
-    // medium — product catalog changes 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())
+    if (params?.collectionSlug) queryParams.set('collectionSlug', params.collectionSlug)
+    if (params?.search) queryParams.set('search', params.search)
+    
+    return useQuery({
+      queryKey: productKeys.list(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products?${queryParams.toString()}`)
+        if (!response.ok) throw new Error('Failed to fetch products')
+        return response.json()
+      },
+      // medium — product catalog changes infrequently
+      ...getCacheTier('medium'),
+    })
+  } catch (error) {
+    logger.warn('[useStorefrontProducts] Called outside QueryClientProvider, returning empty list')
+    return {
+      data: undefined,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: undefined }),
+    } as any
+  }
 }
 
 /**
  * Hook for fetching a single product by slug.
+ * Fetches from Next.js API route to avoid exposing backend URLs.
  */
 export function useProduct(slug: string) {
-  return useQuery({
-    queryKey: productKeys.detail(slug),
-    queryFn: () => getStorefrontProductBySlug(slug),
-    // medium — product details change infrequently
-    ...getCacheTier('medium'),
-    enabled: !!slug,
-  })
+  try {
+    return useQuery({
+      queryKey: productKeys.detail(slug),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/${slug}`)
+        if (!response.ok) throw new Error('Failed to fetch product')
+        return response.json()
+      },
+      // medium — product details change infrequently
+      ...getCacheTier('medium'),
+      enabled: !!slug,
+    })
+  } catch (error) {
+    logger.warn('[useProduct] Called outside QueryClientProvider, returning undefined')
+    return {
+      data: undefined,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: undefined }),
+    } as any
+  }
 }
 
 /**
  * Hook for fetching recommended products.
+ * Fetches from Next.js API route to avoid exposing backend URLs.
  */
 export function useRecommendedProducts(params?: ListParams) {
-  return useQuery({
-    queryKey: productKeys.recommended(params),
-    queryFn: () => getRecommendedProducts(params),
-    // medium — recommendations 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())
+    if (params?.excludeProductId) queryParams.set('excludeProductId', params.excludeProductId)
+    
+    return useQuery({
+      queryKey: productKeys.recommended(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/recommended?${queryParams.toString()}`)
+        if (!response.ok) throw new Error('Failed to fetch recommended products')
+        return response.json()
+      },
+      // medium — recommendations change infrequently
+      ...getCacheTier('medium'),
+    })
+  } catch (error) {
+    logger.warn('[useRecommendedProducts] Called outside QueryClientProvider, returning empty list')
+    return {
+      data: undefined,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: undefined }),
+    } as any
+  }
 }