@spotsdev/sdk 1.0.0 → 1.2.0

package/src/api/mutations/posts.ts

@@ -4,20 +4,26 @@
  * TanStack Query hooks for post/board mutation operations.
  */
 
-import { useMutation, useQueryClient, UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
-import { getApiClient } from '../client';
-import { postKeys } from '../queries/posts';
-import type {
-  Post,
-  PostResponse,
-  CreatePostRequest,
-  CreateReplyRequest,
-  RespondToPostRequest,
-  UpdateResponseRequest,
-  ApiResponse,
-  UpvoteResponse,
-  PostStatusDto,
-} from '../types';
+import {
+  useMutation,
+  type UseMutationOptions,
+  type UseMutationResult,
+  useQueryClient,
+} from '@tanstack/react-query'
+
+import {getApiClient} from '../client'
+import {postKeys} from '../queries/posts'
+import {
+  type ApiResponse,
+  type CreatePostRequest,
+  type CreateReplyRequest,
+  type Post,
+  type PostResponse,
+  type PostStatusDto,
+  type RespondToPostRequest,
+  type UpdateResponseRequest,
+  type UpvoteResponse,
+} from '../types'
 
 // ============================================================================
 // MUTATION HOOKS
@@ -26,253 +32,358 @@ import type {
 /**
  * Create a new post
  *
- * @endpoint POST /api/v1/spots/{spotId}/posts
+ * @endpoint POST /spots/{spotId}/posts
  */
 export function useCreatePost(
-  options?: Omit<UseMutationOptions<Post, Error, { spotId: string } & CreatePostRequest>, 'mutationFn'>
-): UseMutationResult<Post, Error, { spotId: string } & CreatePostRequest> {
-  const queryClient = useQueryClient();
+  options?: Omit<
+    UseMutationOptions<Post, Error, {spotId: string} & CreatePostRequest>,
+    'mutationFn'
+  >,
+): UseMutationResult<Post, Error, {spotId: string} & CreatePostRequest> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async ({ spotId, ...data }): Promise<Post> => {
-      const client = getApiClient();
-      const response = await client.post<ApiResponse<Post>>(`/api/v1/spots/${spotId}/posts`, data);
-      return response.data.data;
+    mutationFn: async ({spotId, ...data}): Promise<Post> => {
+      const client = getApiClient()
+      const response = await client.post<ApiResponse<Post>>(
+        `/spots/${spotId}/posts`,
+        data,
+      )
+      return response.data.data
     },
     onSuccess: (_, variables) => {
-      queryClient.invalidateQueries({ queryKey: postKeys.bySpot(variables.spotId) });
+      queryClient.invalidateQueries({
+        queryKey: postKeys.bySpot(variables.spotId),
+      })
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Update a post
  *
- * @endpoint PUT /api/v1/posts/{postId}
+ * @endpoint PUT /posts/{postId}
  */
 export function useUpdatePost(
-  options?: Omit<UseMutationOptions<Post, Error, { postId: string; title?: string; content?: string }>, 'mutationFn'>
-): UseMutationResult<Post, Error, { postId: string; title?: string; content?: string }> {
-  const queryClient = useQueryClient();
+  options?: Omit<
+    UseMutationOptions<
+      Post,
+      Error,
+      {postId: string; title?: string; content?: string}
+    >,
+    'mutationFn'
+  >,
+): UseMutationResult<
+  Post,
+  Error,
+  {postId: string; title?: string; content?: string}
+> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async ({ postId, ...data }): Promise<Post> => {
-      const client = getApiClient();
-      const response = await client.put<ApiResponse<Post>>(`/api/v1/posts/${postId}`, data);
-      return response.data.data;
+    mutationFn: async ({postId, ...data}): Promise<Post> => {
+      const client = getApiClient()
+      const response = await client.put<ApiResponse<Post>>(
+        `/posts/${postId}`,
+        data,
+      )
+      return response.data.data
     },
     onSuccess: (data, variables) => {
-      queryClient.setQueryData(postKeys.detail(variables.postId), data);
+      queryClient.setQueryData(postKeys.detail(variables.postId), data)
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Delete a post
  *
- * @endpoint DELETE /api/v1/posts/{postId}
+ * @endpoint DELETE /posts/{postId}
  */
 export function useDeletePost(
-  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 (postId: string): Promise<void> => {
-      const client = getApiClient();
-      await client.delete(`/api/v1/posts/${postId}`);
+      const client = getApiClient()
+      await client.delete(`/posts/${postId}`)
     },
     onSuccess: (_, postId) => {
-      queryClient.invalidateQueries({ queryKey: postKeys.detail(postId) });
-      queryClient.invalidateQueries({ queryKey: postKeys.lists() });
+      queryClient.invalidateQueries({queryKey: postKeys.detail(postId)})
+      queryClient.invalidateQueries({queryKey: postKeys.lists()})
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Fulfill a post (mark as fulfilled)
  *
- * @endpoint PUT /api/v1/posts/{postId}/fulfill
+ * @endpoint PUT /posts/{postId}/fulfill
  */
 export function useFulfillPost(
-  options?: Omit<UseMutationOptions<Post, Error, string>, 'mutationFn'>
+  options?: Omit<UseMutationOptions<Post, Error, string>, 'mutationFn'>,
 ): UseMutationResult<Post, Error, string> {
-  const queryClient = useQueryClient();
+  const queryClient = useQueryClient()
 
   return useMutation({
     mutationFn: async (postId: string): Promise<Post> => {
-      const client = getApiClient();
-      const response = await client.put<ApiResponse<Post>>(`/api/v1/posts/${postId}/fulfill`);
-      return response.data.data;
+      const client = getApiClient()
+      const response = await client.put<ApiResponse<Post>>(
+        `/posts/${postId}/fulfill`,
+      )
+      return response.data.data
     },
     onSuccess: (data, postId) => {
-      queryClient.setQueryData(postKeys.detail(postId), data);
+      queryClient.setQueryData(postKeys.detail(postId), data)
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Upvote/unupvote a post
  *
- * @endpoint POST /api/v1/posts/{postId}/upvote
+ * @endpoint POST /posts/{postId}/upvote
  */
 export function useUpvotePost(
-  options?: Omit<UseMutationOptions<UpvoteResponse, Error, string>, 'mutationFn'>
+  options?: Omit<
+    UseMutationOptions<UpvoteResponse, Error, string>,
+    'mutationFn'
+  >,
 ): UseMutationResult<UpvoteResponse, Error, string> {
-  const queryClient = useQueryClient();
+  const queryClient = useQueryClient()
 
   return useMutation({
     mutationFn: async (postId: string): Promise<UpvoteResponse> => {
-      const client = getApiClient();
-      const response = await client.post<ApiResponse<UpvoteResponse>>(`/api/v1/posts/${postId}/upvote`);
-      return response.data.data;
+      const client = getApiClient()
+      const response = await client.post<ApiResponse<UpvoteResponse>>(
+        `/posts/${postId}/upvote`,
+      )
+      return response.data.data
     },
     onSuccess: (_, postId) => {
-      queryClient.invalidateQueries({ queryKey: postKeys.detail(postId) });
+      queryClient.invalidateQueries({queryKey: postKeys.detail(postId)})
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Create a reply to a post
  *
- * @endpoint POST /api/v1/posts/{postId}/reply
+ * @endpoint POST /posts/{postId}/reply
  */
 export function useCreateReply(
-  options?: Omit<UseMutationOptions<unknown, Error, { postId: string } & CreateReplyRequest>, 'mutationFn'>
-): UseMutationResult<unknown, Error, { postId: string } & CreateReplyRequest> {
-  const queryClient = useQueryClient();
+  options?: Omit<
+    UseMutationOptions<unknown, Error, {postId: string} & CreateReplyRequest>,
+    'mutationFn'
+  >,
+): UseMutationResult<unknown, Error, {postId: string} & CreateReplyRequest> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async ({ postId, ...data }) => {
-      const client = getApiClient();
-      const response = await client.post<ApiResponse<unknown>>(`/api/v1/posts/${postId}/reply`, data);
-      return response.data.data;
+    mutationFn: async ({postId, ...data}) => {
+      const client = getApiClient()
+      const response = await client.post<ApiResponse<unknown>>(
+        `/posts/${postId}/reply`,
+        data,
+      )
+      return response.data.data
     },
     onSuccess: (_, variables) => {
-      queryClient.invalidateQueries({ queryKey: postKeys.detail(variables.postId) });
+      queryClient.invalidateQueries({
+        queryKey: postKeys.detail(variables.postId),
+      })
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Delete a reply
  *
- * @endpoint DELETE /api/v1/replies/{replyId}
+ * @endpoint DELETE /replies/{replyId}
  */
 export function useDeleteReply(
-  options?: Omit<UseMutationOptions<void, Error, { replyId: string; postId: string }>, 'mutationFn'>
-): UseMutationResult<void, Error, { replyId: string; postId: string }> {
-  const queryClient = useQueryClient();
+  options?: Omit<
+    UseMutationOptions<void, Error, {replyId: string; postId: string}>,
+    'mutationFn'
+  >,
+): UseMutationResult<void, Error, {replyId: string; postId: string}> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async ({ replyId }): Promise<void> => {
-      const client = getApiClient();
-      await client.delete(`/api/v1/replies/${replyId}`);
+    mutationFn: async ({replyId}): Promise<void> => {
+      const client = getApiClient()
+      await client.delete(`/replies/${replyId}`)
     },
     onSuccess: (_, variables) => {
-      queryClient.invalidateQueries({ queryKey: postKeys.detail(variables.postId) });
+      queryClient.invalidateQueries({
+        queryKey: postKeys.detail(variables.postId),
+      })
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Respond to a post (express interest)
  *
- * @endpoint POST /api/v1/posts/{postId}/respond
+ * @endpoint POST /posts/{postId}/respond
  */
 export function useRespondToPost(
-  options?: Omit<UseMutationOptions<PostResponse, Error, { postId: string } & RespondToPostRequest>, 'mutationFn'>
-): UseMutationResult<PostResponse, Error, { postId: string } & RespondToPostRequest> {
-  const queryClient = useQueryClient();
+  options?: Omit<
+    UseMutationOptions<
+      PostResponse,
+      Error,
+      {postId: string} & RespondToPostRequest
+    >,
+    'mutationFn'
+  >,
+): UseMutationResult<
+  PostResponse,
+  Error,
+  {postId: string} & RespondToPostRequest
+> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async ({ postId, ...data }): Promise<PostResponse> => {
-      const client = getApiClient();
-      const response = await client.post<ApiResponse<PostResponse>>(`/api/v1/posts/${postId}/respond`, data);
-      return response.data.data;
+    mutationFn: async ({postId, ...data}): Promise<PostResponse> => {
+      const client = getApiClient()
+      const response = await client.post<ApiResponse<PostResponse>>(
+        `/posts/${postId}/respond`,
+        data,
+      )
+      return response.data.data
     },
     onSuccess: (_, variables) => {
-      queryClient.invalidateQueries({ queryKey: postKeys.detail(variables.postId) });
-      queryClient.invalidateQueries({ queryKey: postKeys.responses(variables.postId) });
+      queryClient.invalidateQueries({
+        queryKey: postKeys.detail(variables.postId),
+      })
+      queryClient.invalidateQueries({
+        queryKey: postKeys.responses(variables.postId),
+      })
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Accept or decline a response
  *
- * @endpoint PUT /api/v1/responses/{responseId}
+ * @endpoint PUT /responses/{responseId}
  */
 export function useUpdateResponse(
-  options?: Omit<UseMutationOptions<PostResponse, Error, { responseId: string; postId: string } & UpdateResponseRequest>, 'mutationFn'>
-): UseMutationResult<PostResponse, Error, { responseId: string; postId: string } & UpdateResponseRequest> {
-  const queryClient = useQueryClient();
+  options?: Omit<
+    UseMutationOptions<
+      PostResponse,
+      Error,
+      {responseId: string; postId: string} & UpdateResponseRequest
+    >,
+    'mutationFn'
+  >,
+): UseMutationResult<
+  PostResponse,
+  Error,
+  {responseId: string; postId: string} & UpdateResponseRequest
+> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async ({ responseId, postId: _, ...data }): Promise<PostResponse> => {
-      const client = getApiClient();
-      const response = await client.put<ApiResponse<PostResponse>>(`/api/v1/responses/${responseId}`, data);
-      return response.data.data;
+    mutationFn: async ({
+      responseId,
+      postId: _,
+      ...data
+    }): Promise<PostResponse> => {
+      const client = getApiClient()
+      const response = await client.put<ApiResponse<PostResponse>>(
+        `/responses/${responseId}`,
+        data,
+      )
+      return response.data.data
     },
     onSuccess: (_, variables) => {
-      queryClient.invalidateQueries({ queryKey: postKeys.responses(variables.postId) });
+      queryClient.invalidateQueries({
+        queryKey: postKeys.responses(variables.postId),
+      })
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Report a post
  *
- * @endpoint POST /api/v1/posts/{postId}/report
+ * @endpoint POST /posts/{postId}/report
  */
 export function useReportPost(
-  options?: Omit<UseMutationOptions<void, Error, { postId: string; reason: string; details?: string }>, 'mutationFn'>
-): UseMutationResult<void, Error, { postId: string; reason: string; details?: string }> {
+  options?: Omit<
+    UseMutationOptions<
+      void,
+      Error,
+      {postId: string; reason: string; details?: string}
+    >,
+    'mutationFn'
+  >,
+): UseMutationResult<
+  void,
+  Error,
+  {postId: string; reason: string; details?: string}
+> {
   return useMutation({
-    mutationFn: async ({ postId, ...data }): Promise<void> => {
-      const client = getApiClient();
-      await client.post(`/api/v1/posts/${postId}/report`, data);
+    mutationFn: async ({postId, ...data}): Promise<void> => {
+      const client = getApiClient()
+      await client.post(`/posts/${postId}/report`, data)
     },
     ...options,
-  });
+  })
 }
 
 // PostStatusUpdate matches partial PostStatusDto for updates
 interface PostStatusUpdate {
-  isRead?: boolean;
-  isHidden?: boolean;
-  isPinned?: boolean;
+  isRead?: boolean
+  isHidden?: boolean
+  isPinned?: boolean
 }
 
 /**
  * Update user's status for a post (read/hidden/pinned)
  *
- * @endpoint PUT /api/v1/posts/{postId}/status
+ * @endpoint PUT /posts/{postId}/status
  */
 export function useUpdatePostStatus(
-  options?: Omit<UseMutationOptions<PostStatusDto, Error, { postId: string } & PostStatusUpdate>, 'mutationFn'>
-): UseMutationResult<PostStatusDto, Error, { postId: string } & PostStatusUpdate> {
-  const queryClient = useQueryClient();
+  options?: Omit<
+    UseMutationOptions<
+      PostStatusDto,
+      Error,
+      {postId: string} & PostStatusUpdate
+    >,
+    'mutationFn'
+  >,
+): UseMutationResult<
+  PostStatusDto,
+  Error,
+  {postId: string} & PostStatusUpdate
+> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async ({ postId, ...data }): Promise<PostStatusDto> => {
-      const client = getApiClient();
-      const response = await client.put<ApiResponse<PostStatusDto>>(`/api/v1/posts/${postId}/status`, data);
-      return response.data.data;
+    mutationFn: async ({postId, ...data}): Promise<PostStatusDto> => {
+      const client = getApiClient()
+      const response = await client.put<ApiResponse<PostStatusDto>>(
+        `/posts/${postId}/status`,
+        data,
+      )
+      return response.data.data
     },
     onSuccess: (data, variables) => {
-      queryClient.setQueryData(postKeys.status(variables.postId), data);
+      queryClient.setQueryData(postKeys.status(variables.postId), data)
     },
     ...options,
-  });
+  })
 }