@kasuvia/sdk 0.0.1

package/src/hooks/use-orders.ts

@@ -0,0 +1,64 @@
+/**
+ * Orders Hook
+ * 
+ * React Query hook for order operations.
+ */
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
+import { getOrders, findOrder, createOrder, cancelOrder, trackOrder } from '../services/order.service'
+import type { Order, FindOrderParams, CreateOrderParams } from '../types/store'
+
+export function useOrders(params?: { email?: string; page?: number; page_size?: number }) {
+  return useQuery({
+    queryKey: ['orders', params],
+    queryFn: () => getOrders(params),
+  })
+}
+
+// Alias for useOrders for backward compatibility
+export function useOrdersList(params?: { email?: string; page?: number; page_size?: number }) {
+  return useOrders(params)
+}
+
+export function useFindOrder(params: FindOrderParams) {
+  return useQuery({
+    queryKey: ['order', params],
+    queryFn: () => findOrder(params),
+    enabled: !!params.email && !!params.order_id,
+  })
+}
+
+export function useOrder(params: FindOrderParams) {
+  return useFindOrder(params)
+}
+
+export function useOrderTracking(orderId: string, token?: string) {
+  return useQuery({
+    queryKey: ['order-tracking', orderId, token],
+    queryFn: () => trackOrder(orderId, token),
+    enabled: !!orderId,
+    refetchInterval: 30000, // Refetch every 30 seconds for tracking updates
+  })
+}
+
+export function useCreateOrder() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: createOrder,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['orders'] })
+    },
+  })
+}
+
+export function useCancelOrder() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: ({ orderId, reason }: { orderId: string; reason: string }) =>
+      cancelOrder(orderId, reason),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['orders'] })
+    },
+  })
+}

package/src/hooks/use-payment.ts

@@ -0,0 +1,68 @@
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { paymentService } from "../services/payment.service";
+import { getCacheTier } from "../utils/cache";
+import { isInitialized } from "../config";
+import type { DVACreateRequest, PaymentInitiateRequest } from "../types/payments";
+
+
+/**
+ * Hook for creating a Dedicated Virtual Account (DVA)
+ */
+export function useCreateDVA() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (request: DVACreateRequest) =>
+      paymentService.createDedicatedAccount(request),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['payment'] });
+    },
+  });
+}
+
+/**
+ * Hook for initiating card payment
+ */
+export function useInitiatePayment() {
+  return useMutation({
+    mutationFn: (request: PaymentInitiateRequest) =>
+      paymentService.initiatePayment(request),
+  });
+}
+
+/**
+ * Hook for verifying a transaction
+ */
+export function useVerifyTransaction() {
+  return useMutation({
+    mutationFn: (reference: string) =>
+      paymentService.verifyTransaction(reference),
+  });
+}
+
+/**
+ * Hook for getting transaction status
+ */
+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
+  });
+}
+
+/**
+ * Hook for checking transaction status with automatic polling
+ */
+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
+  });
+}

package/src/hooks/use-products.ts

@@ -0,0 +1,113 @@
+/**
+ * Products Hooks
+ * 
+ * React Query hooks for fetching products.
+ */
+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'
+
+export const productKeys = {
+  all: ["products"] as const,
+  list: (params?: ListParams) => [...productKeys.all, "list", params] as const,
+  detail: (slug: string) => [...productKeys.all, "detail", slug] as const,
+  recommended: (params?: ListParams) => [...productKeys.all, "recommended", params] as const,
+  latest: (params?: ListParams) => [...productKeys.all, "latest", params] as const,
+  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,
+}
+
+/**
+ * Hook for fetching latest products.
+ */
+export function useLatestProducts(params?: ListParams) {
+  return useQuery({
+    queryKey: productKeys.latest(params),
+    queryFn: () => getLatestProducts(params),
+    // medium — latest products change infrequently
+    ...getCacheTier('medium'),
+  })
+}
+
+/**
+ * Hook for fetching popular products.
+ */
+export function usePopularProducts(params?: ListParams) {
+  return useQuery({
+    queryKey: productKeys.popular(params),
+    queryFn: () => getPopularProducts(params),
+    // medium — popular products change infrequently
+    ...getCacheTier('medium'),
+  })
+}
+
+/**
+ * Hook for fetching featured products.
+ */
+export function useFeaturedProducts(params?: ListParams) {
+  return useQuery({
+    queryKey: productKeys.featured(params),
+    queryFn: () => getFeaturedProducts(params),
+    // medium — featured products change infrequently
+    ...getCacheTier('medium'),
+  })
+}
+
+/**
+ * Hook for fetching new products.
+ */
+export function useNewProducts(params?: ListParams) {
+  return useQuery({
+    queryKey: productKeys.new(params),
+    queryFn: () => getNewProducts(params),
+    // medium — new products change infrequently
+    ...getCacheTier('medium'),
+  })
+}
+
+/**
+ * Hook for fetching all active storefront products.
+ */
+export function useStorefrontProducts(params?: ListParams) {
+  return useQuery({
+    queryKey: productKeys.list(params),
+    queryFn: () => getStorefrontProducts(params),
+    // medium — product catalog changes infrequently
+    ...getCacheTier('medium'),
+  })
+}
+
+/**
+ * Hook for fetching a single product by slug.
+ */
+export function useProduct(slug: string) {
+  return useQuery({
+    queryKey: productKeys.detail(slug),
+    queryFn: () => getStorefrontProductBySlug(slug),
+    // medium — product details change infrequently
+    ...getCacheTier('medium'),
+    enabled: !!slug,
+  })
+}
+
+/**
+ * Hook for fetching recommended products.
+ */
+export function useRecommendedProducts(params?: ListParams) {
+  return useQuery({
+    queryKey: productKeys.recommended(params),
+    queryFn: () => getRecommendedProducts(params),
+    // medium — recommendations change infrequently
+    ...getCacheTier('medium'),
+  })
+}

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

@@ -0,0 +1,118 @@
+/**
+ * Service Booking Hooks
+ * 
+ * React Query hooks for service bookings.
+ */
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
+import { serviceBookingService } from '../services/service-booking.service'
+import type {
+  ServiceAppointment,
+  ServiceAppointmentCreatePayload,
+  ServiceDeliverable,
+} from '../types/services'
+
+/**
+ * Get available slots for a service product
+ */
+export function useAvailableSlots(
+  product_id: string,
+  date_from: string,
+  date_to: 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()
+
+  return useMutation({
+    mutationFn: serviceBookingService.bookAppointment,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["appointments"] })
+    },
+  })
+}
+
+/**
+ * Get all appointments for the current user
+ */
+export function useAppointments() {
+  return useQuery({
+    queryKey: ["appointments"],
+    queryFn: serviceBookingService.getAppointments,
+  })
+}
+
+/**
+ * Get a single appointment by ID
+ */
+export function useAppointment(id: string) {
+  return useQuery({
+    queryKey: ["appointment", id],
+    queryFn: () => serviceBookingService.getAppointment(id),
+    enabled: !!id,
+  })
+}
+
+/**
+ * Cancel an appointment
+ */
+export function useCancelAppointment() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: (id: string) => serviceBookingService.cancelAppointment(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["appointments"] })
+    },
+  })
+}
+
+/**
+ * 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,
+  })
+}
+
+/**
+ * Approve a deliverable
+ */
+export function useApproveDeliverable(order_id: string, deliverable_id: string) {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: () =>
+      serviceBookingService.approveDeliverable(order_id, deliverable_id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["deliverables", order_id] })
+    },
+  })
+}
+
+/**
+ * Request revision for a deliverable
+ */
+export function useRequestRevision(order_id: string, deliverable_id: string) {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: (feedback: string) =>
+      serviceBookingService.requestRevision(order_id, deliverable_id, feedback),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["deliverables", order_id] })
+    },
+  })
+}

package/src/hooks/use-states.ts

@@ -0,0 +1,28 @@
+/**
+ * States Hook
+ * 
+ * React Query hook for fetching states for a country.
+ */
+import { useQuery } from '@tanstack/react-query'
+import { authAxios } from '../client/httpClient'
+import type { State } from '../types/ui'
+
+export async function getStates(countryIso: string): Promise<State[]> {
+  if (!countryIso) return []
+  const { data } = await authAxios.get<State[]>('auth/countries/', {
+    params: { iso: countryIso }
+  })
+  return data
+}
+
+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
+  })
+}

package/src/hooks/use-wishlist.ts

@@ -0,0 +1,121 @@
+/**
+ * Wishlist Hooks
+ * 
+ * React Query hooks for wishlist operations.
+ */
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
+import {
+  getWishlist,
+  addToWishlist,
+  removeFromWishlist,
+  removeProductFromWishlist,
+  checkInWishlist,
+} from '../services/wishlist.service'
+import { getCacheTier } from '../utils/cache'
+
+export const wishlistKeys = {
+  all: ["wishlist"] as const,
+  list: () => [...wishlistKeys.all, "list"] as const,
+  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'),
+  })
+}
+
+/**
+ * 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,
+  })
+}
+
+/**
+ * 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'] })
+    },
+  })
+}
+
+/**
+ * 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'] })
+    },
+  })
+}
+
+/**
+ * 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'] })
+    },
+  })
+}
+
+/**
+ * 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,
+  })
+
+  return backendQuery
+}

package/src/index.ts

@@ -0,0 +1,65 @@
+/**
+ * @kasuvia/sdk
+ * 
+ * Kasuvia SDK - Core data fetching, authentication, and API client layer
+ * 
+ * @example
+ * ```ts
+ * import { initSdk, useCart, useOrders } from '@kasuvia/sdk'
+ * 
+ * // Initialize SDK
+ * initSdk({
+ *   businessId: 'B-123ABC',
+ *   storefrontApiKey: 'your-api-key',
+ *   environment: 'production'
+ * })
+ * 
+ * // Configure HTTP clients after initialization
+ * configureHttpClients()
+ * 
+ * // Use in components
+ * function Cart() {
+ *   const { cart, addToCart } = useCart()
+ *   // ...
+ * }
+ * ```
+ */
+
+// Configuration
+export { initSdk, getRuntimeConfig, getBackendUrl, isInitialized, resetConfig } from './config'
+export type { SdkConfig } from './config'
+
+// 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'
+
+// Types
+export * from './types'
+
+// Services
+export * from './services'
+
+// React Hooks
+export * from './hooks'
+
+// Utils
+export { getCacheTier, setEnvironmentMode } from './utils/cache'
+export { logger, setLoggerEnvironmentMode } from './utils/logger'
+export * from './utils/sanitize-url'
+export * from './utils/customer'
+export * from './utils/checkout'
+export * from './utils/error-handler'
+
+// App service functions
+export { googleTranslate } from './services/app.service'

package/src/services/app.service.ts

@@ -0,0 +1,17 @@
+/**
+ * App Service
+ * 
+ * Handles translation and other app-level utilities.
+ */
+
+export async function googleTranslate(text: string, target: string, source = "en"): Promise<string> {
+  if (!text || target === source) return text;
+  try {
+    const url = `https://translate.googleapis.com/translate_a/single?client=gtx&sl=${source}&tl=${target}&dt=t&q=${encodeURIComponent(text)}`;
+    const res = await fetch(url);
+    const data = (await res.json()) as [Array<[string, string]>, ...unknown[]];
+    return (data?.[0] || []).map((s) => s[0]).join("");
+  } catch {
+    return text;
+  }
+}