@kasuvia/sdk 0.0.8 → 0.0.9

package/src/hooks/use-products.ts

@@ -1,311 +1,107 @@
 /**
  * Products Hooks
- * 
- * 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.
+ *
+ * React Query hooks for fetching products via the real GraphQL storefront API.
+ *
+ * REAL BUG FIXED (2026-09-21), live-reproduced: every hook here used to fetch
+ * from a Next.js API route (`/api/products/popular`, `/api/products/featured`,
+ * etc.) — but those routes were deleted earlier this session as confirmed
+ * orphaned (an incomplete grep missed this file as a real consumer, the same
+ * mistake class already caught once for `/api/products/[slug]`). This broke
+ * every home-page rail (Featured/New/Popular/On Sale) and the "You may also
+ * crave" recommended section — all 404s. Fixed by calling the SDK's real
+ * GraphQL service functions directly (product.service.ts), resolving config
+ * from SdkContext the same way every other SDK hook does (see use-orders.ts).
+ * `useLatestProducts`/`useLowStockProducts`/`useStorefrontProducts`/
+ * `useProduct` are NOT restored — confirmed zero real UI consumers anywhere
+ * in kasuvia-storefront (ProductsListing.tsx and the product detail page
+ * both already call the SDK service functions directly, not through a hook).
  */
 import { useQuery } from '@tanstack/react-query'
 import type { ListParams } from '../types/store'
 import { getCacheTier } from '../utils/cache'
-import { logger } from '../utils'
+import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
+import type { SdkConfig } from '../config'
+import {
+  getPopularProducts,
+  getFeaturedProducts,
+  getNewProducts,
+  getOnSaleProducts,
+  getRecommendedProducts,
+} from '../services/product.service'
 
 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,
   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) {
-  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) {
-  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
-  }
+export function usePopularProducts(params?: ListParams, config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: productKeys.popular(params),
+    queryFn: () => getPopularProducts(cfg, params),
+    ...getCacheTier('medium'),
+  })
 }
 
 /**
  * Hook for fetching featured products.
- * Fetches from Next.js API route to avoid exposing backend URLs.
  */
-export function useFeaturedProducts(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.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
-  }
+export function useFeaturedProducts(params?: ListParams, config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: productKeys.featured(params),
+    queryFn: () => getFeaturedProducts(cfg, params),
+    ...getCacheTier('medium'),
+  })
 }
 
 /**
  * Hook for fetching new products.
- * Fetches from Next.js API route to avoid exposing backend URLs.
  */
-export function useNewProducts(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.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
-  }
+export function useNewProducts(params?: ListParams, config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: productKeys.new(params),
+    queryFn: () => getNewProducts(cfg, params),
+    ...getCacheTier('medium'),
+  })
 }
 
 /**
  * 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) {
-  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) {
-  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
-  }
+export function useOnSaleProducts(params?: ListParams, config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: productKeys.onSale(params),
+    queryFn: () => getOnSaleProducts(cfg, params),
+    ...getCacheTier('medium'),
+  })
 }
 
 /**
  * Hook for fetching recommended products.
- * Fetches from Next.js API route to avoid exposing backend URLs.
  */
-export function useRecommendedProducts(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())
-    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
-  }
+export function useRecommendedProducts(params?: ListParams & { excludeProductId?: string }, config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: productKeys.recommended(params),
+    queryFn: () => getRecommendedProducts(cfg, params),
+    ...getCacheTier('medium'),
+  })
 }

package/src/hooks/use-push-notifications.ts

@@ -0,0 +1,122 @@
+'use client';
+
+import { useCallback, useEffect, useState } from 'react';
+import { useVapidPublicKey, useSubscribeToPush, useUnsubscribeFromPush } from './use-notifications';
+import type { SdkConfig } from '../config';
+import { logger } from '../utils/logger';
+
+/**
+ * Converts a base64url VAPID public key (as the backend returns it) into
+ * the raw Uint8Array PushManager.subscribe's applicationServerKey expects —
+ * the standard, well-known conversion every Web Push integration needs.
+ */
+function urlBase64ToUint8Array(base64String: string): Uint8Array<ArrayBuffer> {
+  const padding = '='.repeat((4 - (base64String.length % 4)) % 4);
+  const base64 = (base64String + padding).replace(/-/g, '+').replace(/_/g, '/');
+  const rawData = atob(base64);
+  const outputArray = new Uint8Array(rawData.length);
+  for (let i = 0; i < rawData.length; i++) {
+    outputArray[i] = rawData.charCodeAt(i);
+  }
+  return outputArray;
+}
+
+export type PushPermissionState = 'unsupported' | 'default' | 'granted' | 'denied';
+
+/**
+ * Orchestrates the full Web Push subscribe/unsubscribe flow: registers
+ * /sw.js (the storefront app's own service worker — see its doc comment),
+ * requests Notification permission, subscribes via PushManager with the
+ * real VAPID key from the backend, and POSTs the subscription to
+ * kasuvia-notification-system-go. Returns current state + trigger functions
+ * — no UI of its own, so any storefront can build its own "enable
+ * notifications" affordance around it.
+ */
+export function usePushNotifications(config?: SdkConfig, accessToken?: string | null) {
+  const [permission, setPermission] = useState<PushPermissionState>('default');
+  const [isSubscribed, setIsSubscribed] = useState(false);
+  const [isBusy, setIsBusy] = useState(false);
+
+  const { data: vapid } = useVapidPublicKey(config);
+  const subscribeMutation = useSubscribeToPush(config, accessToken);
+  const unsubscribeMutation = useUnsubscribeFromPush(config, accessToken);
+
+  useEffect(() => {
+    if (typeof window === 'undefined' || !('Notification' in window) || !('serviceWorker' in navigator) || !('PushManager' in window)) {
+      setPermission('unsupported');
+      return;
+    }
+    setPermission(Notification.permission as PushPermissionState);
+
+    navigator.serviceWorker.getRegistration('/sw.js').then(async (reg) => {
+      if (!reg) return;
+      const sub = await reg.pushManager.getSubscription();
+      setIsSubscribed(!!sub);
+    }).catch(() => {
+      // No registration yet — not subscribed.
+    });
+  }, []);
+
+  const subscribe = useCallback(async () => {
+    if (permission === 'unsupported') {
+      throw new Error('Push notifications are not supported in this browser.');
+    }
+    if (!vapid?.public_key) {
+      throw new Error('Notification service is not ready yet. Please try again in a moment.');
+    }
+    setIsBusy(true);
+    try {
+      const perm = await Notification.requestPermission();
+      setPermission(perm as PushPermissionState);
+      if (perm !== 'granted') {
+        throw new Error('Notification permission was not granted.');
+      }
+
+      const registration = await navigator.serviceWorker.register('/sw.js');
+      await navigator.serviceWorker.ready;
+
+      const existing = await registration.pushManager.getSubscription();
+      const pushSubscription = existing ?? await registration.pushManager.subscribe({
+        userVisibleOnly: true,
+        applicationServerKey: urlBase64ToUint8Array(vapid.public_key),
+      });
+
+      const json = pushSubscription.toJSON();
+      if (!json.endpoint || !json.keys?.p256dh || !json.keys?.auth) {
+        throw new Error('Browser returned an incomplete push subscription.');
+      }
+
+      await subscribeMutation.mutateAsync({
+        subscription: {
+          endpoint: json.endpoint,
+          keys: { p256dh: json.keys.p256dh, auth: json.keys.auth },
+        },
+        user_agent: navigator.userAgent,
+      });
+
+      setIsSubscribed(true);
+    } finally {
+      setIsBusy(false);
+    }
+  }, [permission, vapid, subscribeMutation]);
+
+  const unsubscribe = useCallback(async () => {
+    setIsBusy(true);
+    try {
+      const registration = await navigator.serviceWorker.getRegistration('/sw.js');
+      const sub = await registration?.pushManager.getSubscription();
+      if (sub) {
+        await unsubscribeMutation.mutateAsync(sub.endpoint);
+        await sub.unsubscribe();
+      }
+      setIsSubscribed(false);
+    } catch (error) {
+      logger.error('[usePushNotifications] Failed to unsubscribe:', error);
+      throw error;
+    } finally {
+      setIsBusy(false);
+    }
+  }, [unsubscribeMutation]);
+
+  return { permission, isSubscribed, isBusy, subscribe, unsubscribe };
+}

package/src/hooks/use-reviews.ts

@@ -0,0 +1,175 @@
+/**
+ * React Query hooks for Reviews and Comments
+ */
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import * as ReviewService from '../services/review.service'
+import type { SdkConfig } from '../config'
+import type {
+  ReviewCreate, ReviewUpdate, CommentCreate, CommentUpdate,
+  MerchantReplyCreate, ReviewModerationAction, CommentModerationAction
+} from '../types/reviews'
+import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
+
+/**
+ * Hook to create a new review
+ */
+export function useCreateReview(config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const queryClient = useQueryClient()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useMutation({
+    mutationFn: (reviewData: ReviewCreate) => ReviewService.createReview(reviewData, cfg),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['product-reviews'] })
+    },
+  })
+}
+
+/**
+ * Hook to update an existing review
+ */
+export function useUpdateReview(config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const queryClient = useQueryClient()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useMutation({
+    mutationFn: ({ reviewId, reviewData }: { reviewId: string; reviewData: ReviewUpdate }) =>
+      ReviewService.updateReview(reviewId, reviewData, cfg),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['product-reviews'] })
+    },
+  })
+}
+
+/**
+ * Hook to get product reviews
+ */
+export function useProductReviews(productId: string, params?: { page?: number; page_size?: number }, config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: ['product-reviews', productId, params],
+    queryFn: () => ReviewService.getProductReviews(productId, params, cfg),
+    enabled: !!productId,
+  })
+}
+
+/**
+ * Hook to create a new comment
+ */
+export function useCreateComment(config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const queryClient = useQueryClient()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useMutation({
+    mutationFn: (commentData: CommentCreate) => ReviewService.createComment(commentData, cfg),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['product-comments'] })
+    },
+  })
+}
+
+/**
+ * Hook to update an existing comment
+ */
+export function useUpdateComment(config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const queryClient = useQueryClient()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useMutation({
+    mutationFn: ({ commentId, commentData }: { commentId: string; commentData: CommentUpdate }) =>
+      ReviewService.updateComment(commentId, commentData, cfg),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['product-comments'] })
+    },
+  })
+}
+
+/**
+ * Hook to get product comments
+ */
+export function useProductComments(productId: string, params?: { page?: number; page_size?: number }, config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: ['product-comments', productId, params],
+    queryFn: () => ReviewService.getProductComments(productId, params, cfg),
+    enabled: !!productId,
+  })
+}
+
+/**
+ * Hook to get pending reviews (merchant/staff only)
+ */
+export function usePendingReviews(config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: ['pending-reviews'],
+    queryFn: () => ReviewService.getPendingReviews(cfg),
+    refetchInterval: 30000,
+  })
+}
+
+/**
+ * Hook to get pending comments (merchant/staff only)
+ */
+export function usePendingComments(config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: ['pending-comments'],
+    queryFn: () => ReviewService.getPendingComments(cfg),
+    refetchInterval: 30000,
+  })
+}
+
+/**
+ * Hook to moderate a review (merchant/staff only)
+ */
+export function useModerateReview(config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const queryClient = useQueryClient()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useMutation({
+    mutationFn: ({ reviewId, action }: { reviewId: string; action: ReviewModerationAction }) =>
+      ReviewService.moderateReview(reviewId, action, cfg),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['pending-reviews'] })
+      queryClient.invalidateQueries({ queryKey: ['product-reviews'] })
+    },
+  })
+}
+
+/**
+ * Hook to moderate a comment (merchant/staff only)
+ */
+export function useModerateComment(config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const queryClient = useQueryClient()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useMutation({
+    mutationFn: ({ commentId, action }: { commentId: string; action: CommentModerationAction }) =>
+      ReviewService.moderateComment(commentId, action, cfg),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['pending-comments'] })
+      queryClient.invalidateQueries({ queryKey: ['product-comments'] })
+    },
+  })
+}
+
+/**
+ * Hook to post a merchant reply to a review (merchant/staff only)
+ */
+export function useMerchantReplyToReview(config?: SdkConfig) {
+  const ctx = useSdkContext()
+  const queryClient = useQueryClient()
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useMutation({
+    mutationFn: ({ reviewId, replyData }: { reviewId: string; replyData: MerchantReplyCreate }) =>
+      ReviewService.merchantReplyToReview(reviewId, replyData, cfg),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['product-reviews'] })
+    },
+  })
+}