added some api

lib/hooks/useProducts.ts

@@ -1,50 +1,216 @@
-import { useQuery } from "@tanstack/react-query"
-import { apiClient } from "@/lib/api"
-import type { Product, PaginatedResponse } from "@/lib/types/api"
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { apiClient } from "@/lib/api";
+import type { Review, Product, PaginatedResponse } from "@/lib/types/api";
 
-interface UseProductsOptions {
-  enabled?: boolean
-  staleTime?: number
-  page?: number
-  perPage?: number
+// Get single review by ID
+export function useReview(
+  reviewId: number | string,
+  options?: { enabled?: boolean }
+) {
+  return useQuery({
+    queryKey: ["review", reviewId],
+    queryFn: async () => {
+      const response = await apiClient.get<Review>(`/reviews/${reviewId}`);
+      return response.data;
+    },
+    enabled: options?.enabled !== false && !!reviewId,
+    staleTime: 1000 * 60 * 10,
+  });
+}
+
+// Get all reviews with pagination
+export function useReviews(options?: {
+  enabled?: boolean;
+  page?: number;
+  limit?: number;
+}) {
+  return useQuery({
+    queryKey: ["reviews", options?.page, options?.limit],
+    queryFn: async () => {
+      const response = await apiClient.get<PaginatedResponse<Review>>(
+        `/reviews`,
+        {
+          params: {
+            page: options?.page || 1,
+            limit: options?.limit,
+          },
+        }
+      );
+      return {
+        data: response.data.data || [],
+        pagination: response.data.pagination || {},
+      };
+    },
+    enabled: options?.enabled !== false,
+    staleTime: 1000 * 60 * 5,
+  });
+}
+
+// Get related reviews for a review
+export function useRelatedReviews(
+  reviewId: number | string,
+  options?: { enabled?: boolean }
+) {
+  return useQuery({
+    queryKey: ["review", reviewId, "related"],
+    queryFn: async () => {
+      const response = await apiClient.get<PaginatedResponse<Review>>(
+        `/reviews/${reviewId}/related`
+      );
+      return response.data.data || response.data;
+    },
+    enabled: options?.enabled !== false && !!reviewId,
+    staleTime: 1000 * 60 * 15,
+  });
 }
 
 export function useProducts(options?: UseProductsOptions) {
   return useQuery({
     queryKey: ["products", options?.page, options?.perPage],
     queryFn: async () => {
-      const response = await apiClient.get<PaginatedResponse<Product>>("/products", {
-        params: {
-          page: options?.page || 1,
-          per_page: options?.perPage || 20,
-        },
-      })
-      return response.data.data || response.data
+      const response = await apiClient.get<PaginatedResponse<Product>>(
+        "/products",
+        {
+          params: {
+            page: options?.page || 1,
+            per_page: options?.perPage || 20,
+          },
+        }
+      );
+      return response.data.data || response.data;
     },
-    staleTime: options?.staleTime ?? 1000 * 60 * 5, // 5 minutes
+    staleTime: options?.staleTime ?? 1000 * 60 * 5,
     enabled: options?.enabled !== false,
-  })
+  });
 }
 
-export function useProduct(id: number | string, options?: { enabled?: boolean }) {
+// Get single product by ID (for review context)
+export function useProduct(
+  productId: number | string,
+  options?: { enabled?: boolean }
+) {
   return useQuery({
-    queryKey: ["product", id],
+    queryKey: ["product", productId],
     queryFn: async () => {
-      const response = await apiClient.get<Product>(`/products/${id}`)
-      return response.data
+      const response = await apiClient.get<Product>(`/products/${productId}`);
+      return response.data;
     },
-    staleTime: 1000 * 60 * 10, // 10 minutes
-    enabled: options?.enabled !== false && !!id,
-  })
+    enabled: options?.enabled !== false && !!productId,
+    staleTime: 1000 * 60 * 10,
+  });
 }
 
-export function useProductsBySlug(slug: string, options?: { enabled?: boolean }) {
+export function useProductsBySlug(
+  slug: string,
+  options?: { enabled?: boolean }
+) {
   return useQuery({
     queryKey: ["products", "slug", slug],
     queryFn: async () => {
-      const response = await apiClient.get<Product>(`/products/${slug}`)
-      return response.data
+      const response = await apiClient.get(`/products/${slug}`);
+      // API returns { message: "success", data: {...} }
+      return response.data.data || response.data;
     },
     enabled: options?.enabled !== false && !!slug,
-  })
+    staleTime: 1000 * 60 * 10,
+  });
+}
+
+// Submit review mutation
+export function useSubmitReview() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      productId,
+      rating,
+      title,
+      source,
+    }: {
+      productId: number | string;
+      rating: number;
+      title: string;
+      source: string;
+    }) => {
+      const response = await apiClient.post<Review>(
+        `/products/${productId}/reviews`,
+        { rating, title, source },
+        {
+          headers: {
+            "Content-Type": "application/json",
+          },
+        }
+      );
+      return response.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: ["reviews", "product", variables.productId],
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["product", variables.productId],
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["reviews"],
+      });
+    },
+  });
+}
+
+// Update review mutation
+export function useUpdateReview() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      reviewId,
+      rating,
+      title,
+      source,
+    }: {
+      reviewId: number | string;
+      rating?: number;
+      title?: string;
+      source?: string;
+    }) => {
+      const response = await apiClient.put<Review>(
+        `/reviews/${reviewId}`,
+        { rating, title, source },
+        {
+          headers: {
+            "Content-Type": "application/json",
+          },
+        }
+      );
+      return response.data;
+    },
+    onSuccess: (data, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: ["review", variables.reviewId],
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["reviews"],
+      });
+    },
+  });
+}
+
+// Delete review mutation
+export function useDeleteReview() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (reviewId: number | string) => {
+      const response = await apiClient.delete(`/reviews/${reviewId}`);
+      return response.data;
+    },
+    onSuccess: (_, reviewId) => {
+      queryClient.invalidateQueries({
+        queryKey: ["review", reviewId],
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["reviews"],
+      });
+    },
+  });
 }