@spotsdev/sdk 1.0.0 → 1.1.0

package/src/api/mutations/products.ts

@@ -4,49 +4,54 @@
  * TanStack Query hooks for product mutation operations.
  */
 
-import { useMutation, useQueryClient, UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
-import { getApiClient } from '../client';
-import { productKeys } from '../queries/products';
-import type { Product, ProductType, ProductStatus, ApiResponse } from '../types';
+import {
+  useMutation,
+  useQueryClient,
+  type UseMutationOptions,
+  type UseMutationResult,
+} from '@tanstack/react-query'
+import {getApiClient} from '../client'
+import {productKeys} from '../queries/products'
+import type {Product, ProductType, ProductStatus, ApiResponse} from '../types'
 
 // ============================================================================
 // TYPES
 // ============================================================================
 
 export interface CreateProductRequest {
-  spotId: string;
-  name: string;
-  description?: string;
-  type: ProductType;
-  price: number;
-  currency?: string;
-  stockQuantity?: number;
-  lowStockThreshold?: number;
-  validFrom?: string;
-  validUntil?: string;
-  deliveryRadiusKm?: number;
-  prepTimeMinutes?: number;
-  maxCapacity?: number;
-  eventDate?: string;
-  imageUrl?: string;
-  metadata?: Record<string, unknown>;
+  spotId: string
+  name: string
+  description?: string
+  type: ProductType
+  price: number
+  currency?: string
+  stockQuantity?: number
+  lowStockThreshold?: number
+  validFrom?: string
+  validUntil?: string
+  deliveryRadiusKm?: number
+  prepTimeMinutes?: number
+  maxCapacity?: number
+  eventDate?: string
+  imageUrl?: string
+  metadata?: Record<string, unknown>
 }
 
 export interface UpdateProductRequest {
-  name?: string;
-  description?: string;
-  price?: number;
-  stockQuantity?: number;
-  lowStockThreshold?: number;
-  status?: ProductStatus;
-  validFrom?: string;
-  validUntil?: string;
-  deliveryRadiusKm?: number;
-  prepTimeMinutes?: number;
-  maxCapacity?: number;
-  eventDate?: string;
-  imageUrl?: string;
-  metadata?: Record<string, unknown>;
+  name?: string
+  description?: string
+  price?: number
+  stockQuantity?: number
+  lowStockThreshold?: number
+  status?: ProductStatus
+  validFrom?: string
+  validUntil?: string
+  deliveryRadiusKm?: number
+  prepTimeMinutes?: number
+  maxCapacity?: number
+  eventDate?: string
+  imageUrl?: string
+  metadata?: Record<string, unknown>
 }
 
 // ============================================================================
@@ -56,105 +61,139 @@ export interface UpdateProductRequest {
 /**
  * Create a new product
  *
- * @endpoint POST /api/v1/spots/{spotId}/products
+ * @endpoint POST /spots/{spotId}/products
  */
 export function useCreateProduct(
-  options?: Omit<UseMutationOptions<Product, Error, CreateProductRequest>, 'mutationFn'>
+  options?: Omit<
+    UseMutationOptions<Product, Error, CreateProductRequest>,
+    'mutationFn'
+  >,
 ): UseMutationResult<Product, Error, CreateProductRequest> {
-  const queryClient = useQueryClient();
+  const queryClient = useQueryClient()
 
   return useMutation({
     mutationFn: async (data: CreateProductRequest): Promise<Product> => {
-      const client = getApiClient();
-      const { spotId, ...productData } = data;
+      const client = getApiClient()
+      const {spotId, ...productData} = data
       const response = await client.post<ApiResponse<Product>>(
-        `/api/v1/spots/${spotId}/products`,
-        productData
-      );
-      return response.data.data;
+        `/spots/${spotId}/products`,
+        productData,
+      )
+      return response.data.data
     },
     onSuccess: (_, variables) => {
-      queryClient.invalidateQueries({ queryKey: productKeys.bySpot(variables.spotId) });
-      queryClient.invalidateQueries({ queryKey: productKeys.list({ my: true }) });
+      queryClient.invalidateQueries({queryKey: productKeys.bySpot(variables.spotId)})
+      queryClient.invalidateQueries({queryKey: productKeys.list({my: true})})
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Update a product
  *
- * @endpoint PUT /api/v1/products/{productId}
+ * @endpoint PUT /products/{productId}
  */
 export function useUpdateProduct(
-  options?: Omit<UseMutationOptions<Product, Error, { productId: string; data: UpdateProductRequest }>, 'mutationFn'>
-): UseMutationResult<Product, Error, { productId: string; data: UpdateProductRequest }> {
-  const queryClient = useQueryClient();
+  options?: Omit<
+    UseMutationOptions<
+      Product,
+      Error,
+      {productId: string; data: UpdateProductRequest}
+    >,
+    'mutationFn'
+  >,
+): UseMutationResult<
+  Product,
+  Error,
+  {productId: string; data: UpdateProductRequest}
+> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async ({ productId, data }): Promise<Product> => {
-      const client = getApiClient();
-      const response = await client.put<ApiResponse<Product>>(`/api/v1/products/${productId}`, data);
-      return response.data.data;
+    mutationFn: async ({productId, data}): Promise<Product> => {
+      const client = getApiClient()
+      const response = await client.put<ApiResponse<Product>>(
+        `/products/${productId}`,
+        data,
+      )
+      return response.data.data
     },
     onSuccess: (data) => {
-      queryClient.setQueryData(productKeys.detail(data.id), data);
-      queryClient.invalidateQueries({ queryKey: productKeys.bySpot(data.spotId) });
-      queryClient.invalidateQueries({ queryKey: productKeys.list({ my: true }) });
+      queryClient.setQueryData(productKeys.detail(data.id), data)
+      queryClient.invalidateQueries({queryKey: productKeys.bySpot(data.spotId)})
+      queryClient.invalidateQueries({queryKey: productKeys.list({my: true})})
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Delete a product
  *
- * @endpoint DELETE /api/v1/products/{productId}
+ * @endpoint DELETE /products/{productId}
  */
 export function useDeleteProduct(
-  options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>
+  options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>,
 ): UseMutationResult<void, Error, string> {
-  const queryClient = useQueryClient();
+  const queryClient = useQueryClient()
 
   return useMutation({
     mutationFn: async (productId: string): Promise<void> => {
-      const client = getApiClient();
-      await client.delete(`/api/v1/products/${productId}`);
+      const client = getApiClient()
+      await client.delete(`/products/${productId}`)
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: productKeys.all });
+      queryClient.invalidateQueries({queryKey: productKeys.all})
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Adjust product stock
  *
- * @endpoint POST /api/v1/products/{productId}/stock
+ * @endpoint POST /products/{productId}/stock
  */
 export function useAdjustStock(
   options?: Omit<
-    UseMutationOptions<Product, Error, { productId: string; quantity: number; reason: 'RESTOCK' | 'ADJUSTMENT'; notes?: string }>,
+    UseMutationOptions<
+      Product,
+      Error,
+      {
+        productId: string
+        quantity: number
+        reason: 'RESTOCK' | 'ADJUSTMENT'
+        notes?: string
+      }
+    >,
     'mutationFn'
-  >
-): UseMutationResult<Product, Error, { productId: string; quantity: number; reason: 'RESTOCK' | 'ADJUSTMENT'; notes?: string }> {
-  const queryClient = useQueryClient();
+  >,
+): UseMutationResult<
+  Product,
+  Error,
+  {
+    productId: string
+    quantity: number
+    reason: 'RESTOCK' | 'ADJUSTMENT'
+    notes?: string
+  }
+> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async ({ productId, quantity, reason, notes }): Promise<Product> => {
-      const client = getApiClient();
-      const response = await client.post<ApiResponse<Product>>(`/api/v1/products/${productId}/stock`, {
-        quantity,
-        reason,
-        notes,
-      });
-      return response.data.data;
+    mutationFn: async ({productId, quantity, reason, notes}): Promise<Product> => {
+      const client = getApiClient()
+      const response = await client.post<ApiResponse<Product>>(
+        `/products/${productId}/stock`,
+        {quantity, reason, notes},
+      )
+      return response.data.data
     },
     onSuccess: (data) => {
-      queryClient.setQueryData(productKeys.detail(data.id), data);
-      queryClient.invalidateQueries({ queryKey: productKeys.bySpot(data.spotId) });
+      queryClient.setQueryData(productKeys.detail(data.id), data)
+      queryClient.invalidateQueries({queryKey: productKeys.bySpot(data.spotId)})
     },
     ...options,
-  });
+  })
 }

package/src/api/mutations/spots.ts

@@ -4,11 +4,17 @@
  * TanStack Query hooks for spot mutation operations.
  */
 
-import { useMutation, useQueryClient, UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
-import { getApiClient } from '../client';
-import { spotKeys } from '../queries/spots';
-import { userKeys } from '../queries/users';
-import type { Spot, ClaimSpotRequest, ApiResponse } from '../types';
+import {
+  useMutation,
+  type UseMutationOptions,
+  type UseMutationResult,
+  useQueryClient,
+} from '@tanstack/react-query'
+
+import {getApiClient} from '../client'
+import {spotKeys} from '../queries/spots'
+import {userKeys} from '../queries/users'
+import {type ApiResponse, type ClaimSpotRequest, type Spot} from '../types'
 
 // ============================================================================
 // MUTATION HOOKS
@@ -17,130 +23,236 @@ import type { Spot, ClaimSpotRequest, ApiResponse } from '../types';
 /**
  * Create a new spot
  *
- * @endpoint POST /api/v1/spots
+ * @endpoint POST /spots
  */
 export function useCreateSpot(
-  options?: Omit<UseMutationOptions<Spot, Error, Partial<Spot>>, 'mutationFn'>
+  options?: Omit<UseMutationOptions<Spot, Error, Partial<Spot>>, 'mutationFn'>,
 ): UseMutationResult<Spot, Error, Partial<Spot>> {
-  const queryClient = useQueryClient();
+  const queryClient = useQueryClient()
 
   return useMutation({
     mutationFn: async (data: Partial<Spot>): Promise<Spot> => {
-      const client = getApiClient();
-      const response = await client.post<ApiResponse<Spot>>('/api/v1/spots', data);
-      return response.data.data;
+      const client = getApiClient()
+      const response = await client.post<ApiResponse<Spot>>('/spots', data)
+      return response.data.data
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: spotKeys.lists() });
+      queryClient.invalidateQueries({queryKey: spotKeys.lists()})
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Update a spot
  *
- * @endpoint PUT /api/v1/spots/{spotId}
+ * @endpoint PUT /spots/{spotId}
  */
 export function useUpdateSpot(
-  options?: Omit<UseMutationOptions<Spot, Error, { spotId: string } & Partial<Spot>>, 'mutationFn'>
-): UseMutationResult<Spot, Error, { spotId: string } & Partial<Spot>> {
-  const queryClient = useQueryClient();
+  options?: Omit<
+    UseMutationOptions<Spot, Error, {spotId: string} & Partial<Spot>>,
+    'mutationFn'
+  >,
+): UseMutationResult<Spot, Error, {spotId: string} & Partial<Spot>> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async ({ spotId, ...data }): Promise<Spot> => {
-      const client = getApiClient();
-      const response = await client.put<ApiResponse<Spot>>(`/api/v1/spots/${spotId}`, data);
-      return response.data.data;
+    mutationFn: async ({spotId, ...data}): Promise<Spot> => {
+      const client = getApiClient()
+      const response = await client.put<ApiResponse<Spot>>(
+        `/spots/${spotId}`,
+        data,
+      )
+      return response.data.data
     },
     onSuccess: (data, variables) => {
-      queryClient.setQueryData(spotKeys.detail(variables.spotId), data);
+      queryClient.setQueryData(spotKeys.detail(variables.spotId), data)
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Claim a spot (for business owners)
  *
- * @endpoint POST /api/v1/spots/{spotId}/claim
+ * @endpoint POST /spots/{spotId}/claim
  */
 export function useClaimSpot(
-  options?: Omit<UseMutationOptions<{ claimId: string }, Error, { spotId: string } & ClaimSpotRequest>, 'mutationFn'>
-): UseMutationResult<{ claimId: string }, Error, { spotId: string } & ClaimSpotRequest> {
+  options?: Omit<
+    UseMutationOptions<
+      {claimId: string},
+      Error,
+      {spotId: string} & ClaimSpotRequest
+    >,
+    'mutationFn'
+  >,
+): UseMutationResult<
+  {claimId: string},
+  Error,
+  {spotId: string} & ClaimSpotRequest
+> {
   return useMutation({
-    mutationFn: async ({ spotId, ...data }): Promise<{ claimId: string }> => {
-      const client = getApiClient();
-      const response = await client.post<ApiResponse<{ claimId: string }>>(`/api/v1/spots/${spotId}/claim`, data);
-      return response.data.data;
+    mutationFn: async ({spotId, ...data}): Promise<{claimId: string}> => {
+      const client = getApiClient()
+      const response = await client.post<ApiResponse<{claimId: string}>>(
+        `/spots/${spotId}/claim`,
+        data,
+      )
+      return response.data.data
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Subscribe to a spot
  *
- * @endpoint POST /api/v1/spots/{spotId}/subscribe
+ * @endpoint POST /spots/{spotId}/subscribe
  */
 export function useSubscribeToSpot(
-  options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>
+  options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>,
 ): UseMutationResult<void, Error, string> {
-  const queryClient = useQueryClient();
+  const queryClient = useQueryClient()
 
   return useMutation({
     mutationFn: async (spotId: string): Promise<void> => {
-      const client = getApiClient();
-      await client.post(`/api/v1/spots/${spotId}/subscribe`);
+      const client = getApiClient()
+      await client.post(`/spots/${spotId}/subscribe`)
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: userKeys.subscriptions() });
+      queryClient.invalidateQueries({queryKey: userKeys.subscriptions()})
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Unsubscribe from a spot
  *
- * @endpoint DELETE /api/v1/spots/{spotId}/subscribe
+ * @endpoint DELETE /spots/{spotId}/subscribe
  */
 export function useUnsubscribeFromSpot(
-  options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>
+  options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>,
 ): UseMutationResult<void, Error, string> {
-  const queryClient = useQueryClient();
+  const queryClient = useQueryClient()
 
   return useMutation({
     mutationFn: async (spotId: string): Promise<void> => {
-      const client = getApiClient();
-      await client.delete(`/api/v1/spots/${spotId}/subscribe`);
+      const client = getApiClient()
+      await client.delete(`/spots/${spotId}/subscribe`)
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: userKeys.subscriptions() });
+      queryClient.invalidateQueries({queryKey: userKeys.subscriptions()})
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Toggle favorite status on a spot
  *
- * @endpoint POST /api/v1/spots/{spotId}/favorite
+ * @endpoint POST /spots/{spotId}/favorite
  */
 export function useFavoriteSpot(
-  options?: Omit<UseMutationOptions<{ isFavorite: boolean }, Error, string>, 'mutationFn'>
-): UseMutationResult<{ isFavorite: boolean }, Error, string> {
-  const queryClient = useQueryClient();
+  options?: Omit<
+    UseMutationOptions<{isFavorite: boolean}, Error, string>,
+    'mutationFn'
+  >,
+): UseMutationResult<{isFavorite: boolean}, Error, string> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async (spotId: string): Promise<{ isFavorite: boolean }> => {
-      const client = getApiClient();
-      const response = await client.post<ApiResponse<{ isFavorite: boolean }>>(`/api/v1/spots/${spotId}/favorite`);
-      return response.data.data;
+    mutationFn: async (spotId: string): Promise<{isFavorite: boolean}> => {
+      const client = getApiClient()
+      const response = await client.post<ApiResponse<{isFavorite: boolean}>>(
+        `/spots/${spotId}/favorite`,
+      )
+      return response.data.data
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: userKeys.favorites() });
+      queryClient.invalidateQueries({queryKey: userKeys.favorites()})
+    },
+    ...options,
+  })
+}
+
+/**
+ * Rate a spot
+ *
+ * @endpoint POST /spots/{spotId}/rate
+ */
+export function useRateSpot(
+  options?: Omit<
+    UseMutationOptions<
+      {rating: number},
+      Error,
+      {spotId: string; rating: number}
+    >,
+    'mutationFn'
+  >,
+): UseMutationResult<
+  {rating: number},
+  Error,
+  {spotId: string; rating: number}
+> {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: async ({
+      spotId,
+      rating,
+    }: {
+      spotId: string
+      rating: number
+    }): Promise<{rating: number}> => {
+      const client = getApiClient()
+      const response = await client.post<ApiResponse<{rating: number}>>(
+        `/spots/${spotId}/rate`,
+        {rating},
+      )
+      return response.data.data
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: spotKeys.detail(variables.spotId),
+      })
+    },
+    ...options,
+  })
+}
+
+/**
+ * Report a spot
+ *
+ * @endpoint POST /spots/{spotId}/report
+ */
+export function useReportSpot(
+  options?: Omit<
+    UseMutationOptions<
+      {success: boolean},
+      Error,
+      {spotId: string; reason: string; details?: string}
+    >,
+    'mutationFn'
+  >,
+): UseMutationResult<
+  {success: boolean},
+  Error,
+  {spotId: string; reason: string; details?: string}
+> {
+  return useMutation({
+    mutationFn: async ({
+      spotId,
+      reason,
+      details,
+    }): Promise<{success: boolean}> => {
+      const client = getApiClient()
+      const response = await client.post<ApiResponse<{success: boolean}>>(
+        `/spots/${spotId}/report`,
+        {reason, details},
+      )
+      return response.data.data
     },
     ...options,
-  });
+  })
 }