@kasuvia/sdk 0.0.8 → 0.0.9

package/src/hooks/use-orders.ts

@@ -5,34 +5,34 @@
  * config and accessToken are optional — if omitted, they are read from SdkContext.
  */
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { getOrders, findOrder, createOrder, cancelOrder, trackOrder } from '../services/order.service'
+import { getOrders, findOrder, createOrder, cancelOrder, trackOrder, createBespokeOrder, createServiceBookingOrder } from '../services/order.service'
 import type { FindOrderParams, CreateOrderParams } from '../types/store'
+import type { CreateBespokeOrderParams, CreateServiceBookingOrderParams } from '../services/order.service'
 import type { SdkConfig } from '../config'
-import { logger } from '../utils'
 import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
 
-export function useOrders(arg1?: SdkConfig | { page?: number; pageSize?: number }, arg2?: string | null, arg3?: { page?: number; pageSize?: number }) {
+// REAL BUG FIXED (2026-09-21): this used `pageSize` (camelCase), but the
+// real `getOrders` param it's forwarded to reads `page_size` (snake_case,
+// matching every other Kasuvia paginated endpoint) — the value was silently
+// dropped on every call, always falling back to the backend's default page
+// size instead of the caller's requested one.
+export function useOrders(arg1?: SdkConfig | { page?: number; page_size?: number }, arg2?: string | null, arg3?: { page?: number; page_size?: 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)
+  const params = isArg1Config ? arg3 : (arg1 as { page?: number; page_size?: number } | undefined)
 
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
-    return useQuery({
-      queryKey: ['orders', params],
-      queryFn: () => token ? getOrders(cfg, token, params || {}) : Promise.resolve(undefined),
-      enabled: !!token,
-    })
-  } catch (error) {
-    logger.warn('[useOrders] Called outside QueryClientProvider, returning empty list')
-    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
+  return useQuery({
+    queryKey: ['orders', params],
+    queryFn: () => token ? getOrders(cfg, token, params || {}) : Promise.reject(new Error('No access token available')),
+    enabled: !!token,
+  })
 }
 
-export function useOrdersList(arg1?: any, arg2?: any, arg3?: any) {
-  return useOrders(arg1, arg2, arg3)
+export function useOrdersList(arg1?: unknown, arg2?: unknown, arg3?: unknown) {
+  return useOrders(arg1 as SdkConfig, arg2 as string, arg3 as { page?: number; page_size?: number })
 }
 
 export function useFindOrder(arg1?: SdkConfig | string | FindOrderParams, arg2?: FindOrderParams) {
@@ -45,75 +45,93 @@ export function useFindOrder(arg1?: SdkConfig | string | FindOrderParams, arg2?:
       ? { order_id: arg1, email: '' }
       : (arg1 as FindOrderParams | undefined)
 
-  try {
-    const { config: cfg } = resolveHookArgs(explicitConfig, undefined, ctx)
-    return useQuery({
-      queryKey: ['order', params],
-      queryFn: () => params ? findOrder(cfg, params) : Promise.resolve(undefined),
-      enabled: !!params?.order_id,
-    })
-  } catch (error) {
-    logger.warn('[useFindOrder] Called outside QueryClientProvider, returning undefined')
-    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
-  }
+  const { config: cfg } = resolveHookArgs(explicitConfig, undefined, ctx)
+  return useQuery({
+    queryKey: ['order', params],
+    queryFn: () => params ? findOrder(cfg, params) : Promise.reject(new Error('Missing search parameters')),
+    // findOrder's real backend contract (POST /orders/track) requires both
+    // order_id and email — matches that instead of firing on order_id alone.
+    enabled: !!params?.order_id && !!params?.email,
+  })
 }
 
 export function useOrder(arg1?: SdkConfig | string | FindOrderParams, arg2?: FindOrderParams) {
   return useFindOrder(arg1, arg2)
 }
 
-export function useOrderTracking(arg1?: SdkConfig | string, arg2?: string, arg3?: string) {
+/**
+ * REAL BUG FIXED (2026-09-22): took an arbitrary "guestToken" string —
+ * trackOrder's real backend endpoint (GET /orders/{id}) has no guest-token
+ * concept at all, it requires a genuine authenticated JWT belonging to the
+ * order's own customer (see trackOrder's doc comment). Resolves a real
+ * accessToken from SdkContext like every other authenticated hook instead.
+ */
+export function useOrderTracking(config?: SdkConfig, accessToken?: string | null, orderId?: string) {
   const ctx = useSdkContext()
-  const isArg1Config = typeof arg1 === 'object' && arg1 !== null && 'businessId' in arg1
-  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined
-  const orderId = isArg1Config ? arg2 : (typeof arg1 === 'string' ? arg1 : undefined)
-  const guestToken = isArg1Config ? arg3 : (typeof arg2 === 'string' ? arg2 : undefined)
-
-  try {
-    const { config: cfg } = resolveHookArgs(explicitConfig, undefined, ctx)
-    return useQuery({
-      queryKey: ['order-tracking', orderId, guestToken],
-      queryFn: () => trackOrder(cfg, orderId!, guestToken),
-      enabled: !!orderId,
-      refetchInterval: 30000,
-    })
-  } catch (error) {
-    logger.warn('[useOrderTracking] Called outside QueryClientProvider, returning undefined')
-    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  return useQuery({
+    queryKey: ['order-tracking', orderId],
+    queryFn: () => token && orderId ? trackOrder(cfg, orderId, token) : Promise.reject(new Error('Missing order ID or access token')),
+    enabled: !!orderId && !!token,
+    refetchInterval: 30000,
+  })
 }
 
+/**
+ * REAL BUG FIXED (2026-09-22): passed `token || ''` — an empty string
+ * `accessToken`, which used to produce a malformed `Authorization: Bearer `
+ * header instead of genuinely omitting it. Combined with createOrder's own
+ * fix (see its doc comment), guest checkout through this hook has never
+ * actually worked even though the real backend endpoint was built to
+ * support it via X-Guest-Session — the same guestSessionId SdkContext
+ * already resolves for every useCart() call site now also reaches here.
+ */
 export function useCreateOrder(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: CreateOrderParams) => createOrder(cfg, token || '', payload),
-      onSuccess: () => {
-        queryClient.invalidateQueries({ queryKey: ['orders'] })
-      },
-    })
-  } catch (error) {
-    logger.warn('[useCreateOrder] Called outside QueryClientProvider, returning no-op mutation')
-    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const guestSessionId = ctx?.guestSessionId ?? undefined
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (payload: CreateOrderParams) => createOrder(cfg, token ?? undefined, payload, guestSessionId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['orders'] })
+    },
+  })
+}
+
+export function useCreateBespokeOrder(config?: SdkConfig, accessToken?: string | null) {
+  const ctx = useSdkContext()
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (payload: CreateBespokeOrderParams) => createBespokeOrder(cfg, token || undefined, payload),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['orders'] })
+    },
+  })
+}
+
+export function useCreateServiceBookingOrder(config?: SdkConfig, accessToken?: string | null) {
+  const ctx = useSdkContext()
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (payload: CreateServiceBookingOrderParams) => createServiceBookingOrder(cfg, token || undefined, payload),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['orders'] })
+    },
+  })
 }
 
 export function useCancelOrder(config?: SdkConfig, accessToken?: string | null) {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
-    const queryClient = useQueryClient()
-    return useMutation({
-      mutationFn: ({ orderId, reason = '' }: { orderId: string; reason?: string }) =>
-        token ? cancelOrder(cfg, token, orderId, reason) : Promise.reject('No access token'),
-      onSuccess: () => {
-        queryClient.invalidateQueries({ queryKey: ['orders'] })
-      },
-    })
-  } catch (error) {
-    logger.warn('[useCancelOrder] Called outside QueryClientProvider, returning no-op mutation')
-    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ orderId, reason = '' }: { orderId: string; reason?: string }) =>
+      token ? cancelOrder(cfg, token, orderId, reason) : Promise.reject(new Error('No access token available')),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['orders'] })
+    },
+  })
 }

package/src/hooks/use-payment.ts

@@ -1,55 +1,117 @@
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { createDedicatedAccount, initiatePayment, verifyTransaction, getTransactionStatus } from "../services/payment.service";
+import {
+  createDedicatedAccount,
+  initiatePayment,
+  verifyTransaction,
+  getTransactionStatus,
+  getAvailablePaymentMethods,
+  getWalletBalance,
+  getWalletLedger,
+  claimWalletCredit,
+} 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 fetching available payment methods for a region.
+ *
+ * `currency`/`countryCode` are optional with no SDK-level default — see
+ * getAvailablePaymentMethods' doc comment: the real backend already
+ * declares its own default for this route, so leaving them unset here
+ * lets that be the single source of truth instead of risking a second,
+ * independently-hardcoded copy drifting out of sync with it.
+ */
+export function useAvailablePaymentMethods(
+  config?: SdkConfig,
+  currency?: string,
+  countryCode?: string
+) {
+  const ctx = useSdkContext();
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx);
+  return useQuery({
+    queryKey: ['payment', 'available-methods', currency, countryCode],
+    queryFn: () => getAvailablePaymentMethods(cfg, currency, countryCode),
+  });
+}
+
+/**
+ * Hook for fetching authenticated customer's wallet balance.
+ */
+export function useWalletBalance(config?: SdkConfig, accessToken?: string | null) {
+  const ctx = useSdkContext();
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+  return useQuery({
+    queryKey: ['wallet', 'balance', token],
+    queryFn: () => token ? getWalletBalance(cfg, token) : Promise.reject(new Error('No access token available')),
+    enabled: !!token,
+  });
+}
+
+/**
+ * Hook for fetching authenticated customer's wallet ledger history.
+ */
+export function useWalletLedger(
+  config?: SdkConfig,
+  accessToken?: string | null,
+  params?: { page?: number; page_size?: number }
+) {
+  const ctx = useSdkContext();
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+  const page = params?.page ?? 1;
+  const pageSize = params?.page_size ?? 20;
+
+  return useQuery({
+    queryKey: ['wallet', 'ledger', token, page, pageSize],
+    queryFn: () => token ? getWalletLedger(cfg, token, { page, page_size: pageSize }) : Promise.reject(new Error('No access token available')),
+    enabled: !!token,
+  });
+}
+
+/**
+ * Hook for claiming pending guest wallet credit into customer's wallet.
+ */
+export function useClaimWalletCredit(config?: SdkConfig, accessToken?: string | null) {
+  const ctx = useSdkContext();
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (claimToken: string) =>
+      token ? claimWalletCredit(cfg, token, claimToken) : Promise.reject(new Error('No access token available')),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['wallet'] });
+    },
+  });
+}
+
 /**
  * Hook for creating a Dedicated Virtual Account (DVA)
- * Optional config and accessToken — read from SdkContext if omitted.
+ * Supports both authenticated users and guest checkout.
  */
 export function useCreateDVA(config?: SdkConfig, accessToken?: string | null) {
   const ctx = useSdkContext();
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
-    const queryClient = useQueryClient();
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+  const queryClient = useQueryClient();
 
-    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;
-  }
+  return useMutation({
+    mutationFn: (request: DVACreateRequest) => createDedicatedAccount(cfg, token, request),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['payment'] });
+    },
+  });
 }
 
 /**
- * Hook for initiating card payment
- * Optional config and accessToken — read from SdkContext if omitted.
+ * Hook for initiating payment (card, transfer, etc.)
+ * Supports both authenticated users and guest checkout.
  */
 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;
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+  return useMutation({
+    mutationFn: (request: PaymentInitiateRequest) => initiatePayment(cfg, token, request),
+  });
 }
 
 /**
@@ -58,18 +120,10 @@ export function useInitiatePayment(config?: SdkConfig, accessToken?: string | nu
  */
 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;
-  }
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx);
+  return useMutation({
+    mutationFn: (reference: string) => verifyTransaction(cfg, reference),
+  });
 }
 
 /**
@@ -83,24 +137,13 @@ export function useTransactionStatus(arg1?: SdkConfig | string, arg2?: string |
   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;
-  }
+  const { config: cfg } = resolveHookArgs(explicitConfig, undefined, ctx);
+  return useQuery({
+    queryKey: ['transaction', 'status', transactionId],
+    queryFn: () => getTransactionStatus(cfg, transactionId),
+    enabled: enabled && !!transactionId,
+    refetchInterval: 3000,
+  });
 }
 
 /**
@@ -114,23 +157,12 @@ export function usePollTransactionStatus(arg1?: SdkConfig | string, arg2?: strin
   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;
-  }
+  const { config: cfg } = resolveHookArgs(explicitConfig, undefined, ctx);
+  return useQuery({
+    queryKey: ['transaction', 'poll', reference],
+    queryFn: () => verifyTransaction(cfg, reference),
+    enabled: enabled && !!reference,
+    refetchInterval: 2000,
+    retry: 10,
+  });
 }