@spotsdev/sdk 1.0.0 → 1.1.0

package/src/api/mutations/users.ts

@@ -4,10 +4,16 @@
  * TanStack Query hooks for user mutation operations.
  */
 
-import { useMutation, useQueryClient, UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
-import { getApiClient } from '../client';
-import { userKeys } from '../queries/users';
-import type { User, UpdateProfileRequest, ApiResponse } from '../types';
+import {
+  useMutation,
+  type UseMutationOptions,
+  type UseMutationResult,
+  useQueryClient,
+} from '@tanstack/react-query'
+
+import {getApiClient} from '../client'
+import {userKeys} from '../queries/users'
+import {type ApiResponse, type UpdateProfileRequest, type User} from '../types'
 
 // ============================================================================
 // MUTATION HOOKS
@@ -16,182 +22,209 @@ import type { User, UpdateProfileRequest, ApiResponse } from '../types';
 /**
  * Update current user's profile
  *
- * @endpoint PUT /api/v1/users/me
+ * @endpoint PUT /users/me
  */
 export function useUpdateProfile(
-  options?: Omit<UseMutationOptions<User, Error, UpdateProfileRequest>, 'mutationFn'>
+  options?: Omit<
+    UseMutationOptions<User, Error, UpdateProfileRequest>,
+    'mutationFn'
+  >,
 ): UseMutationResult<User, Error, UpdateProfileRequest> {
-  const queryClient = useQueryClient();
+  const queryClient = useQueryClient()
 
   return useMutation({
     mutationFn: async (data: UpdateProfileRequest): Promise<User> => {
-      const client = getApiClient();
-      const response = await client.put<ApiResponse<User>>('/api/v1/users/me', data);
-      return response.data.data;
+      const client = getApiClient()
+      const response = await client.put<ApiResponse<User>>('/users/me', data)
+      return response.data.data
     },
-    onSuccess: (data) => {
-      queryClient.setQueryData(userKeys.me(), data);
+    onSuccess: data => {
+      queryClient.setQueryData(userKeys.me(), data)
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Upload avatar
  *
- * @endpoint POST /api/v1/users/me/avatar
+ * Uploads avatar file and updates user profile in one request.
+ *
+ * @endpoint POST /users/me/avatar
  */
 export function useUploadAvatar(
-  options?: Omit<UseMutationOptions<{ avatarUrl: string }, Error, FormData>, 'mutationFn'>
-): UseMutationResult<{ avatarUrl: string }, Error, FormData> {
-  const queryClient = useQueryClient();
+  options?: Omit<
+    UseMutationOptions<{avatarUrl: string}, Error, FormData>,
+    'mutationFn'
+  >,
+): UseMutationResult<{avatarUrl: string}, Error, FormData> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async (formData: FormData): Promise<{ avatarUrl: string }> => {
-      const client = getApiClient();
-      const response = await client.post<ApiResponse<{ avatarUrl: string }>>('/api/v1/users/me/avatar', formData, {
-        headers: { 'Content-Type': 'multipart/form-data' },
-      });
-      return response.data.data;
+    mutationFn: async (formData: FormData): Promise<{avatarUrl: string}> => {
+      const client = getApiClient()
+      const response = await client.post<ApiResponse<{avatarUrl: string}>>(
+        '/users/me/avatar',
+        formData,
+        {
+          headers: {'Content-Type': 'multipart/form-data'},
+        },
+      )
+      return response.data.data
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: userKeys.me() });
+      queryClient.invalidateQueries({queryKey: userKeys.me()})
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Delete current user's account
  *
- * @endpoint DELETE /api/v1/users/me
+ * @endpoint DELETE /users/me
  */
 export function useDeleteAccount(
-  options?: Omit<UseMutationOptions<void, Error, void>, 'mutationFn'>
+  options?: Omit<UseMutationOptions<void, Error, void>, 'mutationFn'>,
 ): UseMutationResult<void, Error, void> {
-  const queryClient = useQueryClient();
+  const queryClient = useQueryClient()
 
   return useMutation({
     mutationFn: async (): Promise<void> => {
-      const client = getApiClient();
-      await client.delete('/api/v1/users/me');
+      const client = getApiClient()
+      await client.delete('/users/me')
     },
     onSuccess: () => {
-      queryClient.clear();
+      queryClient.clear()
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Update user vibes
  *
- * @endpoint PUT /api/v1/user/me/vibes
+ * @endpoint PUT /users/me/vibes
  */
 export function useUpdateVibes(
-  options?: Omit<UseMutationOptions<User, Error, { vibes: string[] }>, 'mutationFn'>
-): UseMutationResult<User, Error, { vibes: string[] }> {
-  const queryClient = useQueryClient();
+  options?: Omit<
+    UseMutationOptions<User, Error, {vibes: string[]}>,
+    'mutationFn'
+  >,
+): UseMutationResult<User, Error, {vibes: string[]}> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async (data: { vibes: string[] }): Promise<User> => {
-      const client = getApiClient();
-      const response = await client.put<ApiResponse<User>>('/api/v1/user/me/vibes', data);
-      return response.data.data;
+    mutationFn: async (data: {vibes: string[]}): Promise<User> => {
+      const client = getApiClient()
+      const response = await client.put<ApiResponse<User>>(
+        '/users/me/vibes',
+        data,
+      )
+      return response.data.data
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: userKeys.me() });
+      queryClient.invalidateQueries({queryKey: userKeys.me()})
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Update user interests
  *
- * @endpoint PUT /api/v1/user/me/interests
+ * @endpoint PUT /user/me/interests
  */
 export function useUpdateInterests(
-  options?: Omit<UseMutationOptions<User, Error, { interests: string[] }>, 'mutationFn'>
-): UseMutationResult<User, Error, { interests: string[] }> {
-  const queryClient = useQueryClient();
+  options?: Omit<
+    UseMutationOptions<User, Error, {interests: string[]}>,
+    'mutationFn'
+  >,
+): UseMutationResult<User, Error, {interests: string[]}> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async (data: { interests: string[] }): Promise<User> => {
-      const client = getApiClient();
-      const response = await client.put<ApiResponse<User>>('/api/v1/user/me/interests', data);
-      return response.data.data;
+    mutationFn: async (data: {interests: string[]}): Promise<User> => {
+      const client = getApiClient()
+      const response = await client.put<ApiResponse<User>>(
+        '/user/me/interests',
+        data,
+      )
+      return response.data.data
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: userKeys.me() });
+      queryClient.invalidateQueries({queryKey: userKeys.me()})
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Complete onboarding step
  *
- * @endpoint POST /api/v1/user/me/onboarding-step
+ * @endpoint POST /user/me/onboarding-step
  */
 export function useCompleteOnboardingStep(
-  options?: Omit<UseMutationOptions<User, Error, { step: number }>, 'mutationFn'>
-): UseMutationResult<User, Error, { step: number }> {
-  const queryClient = useQueryClient();
+  options?: Omit<UseMutationOptions<User, Error, {step: number}>, 'mutationFn'>,
+): UseMutationResult<User, Error, {step: number}> {
+  const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: async (data: { step: number }): Promise<User> => {
-      const client = getApiClient();
-      const response = await client.post<ApiResponse<User>>('/api/v1/user/me/onboarding-step', data);
-      return response.data.data;
+    mutationFn: async (data: {step: number}): Promise<User> => {
+      const client = getApiClient()
+      const response = await client.post<ApiResponse<User>>(
+        '/user/me/onboarding-step',
+        data,
+      )
+      return response.data.data
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: userKeys.me() });
+      queryClient.invalidateQueries({queryKey: userKeys.me()})
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Block a user
  *
- * @endpoint POST /api/v1/users/{id}/block
+ * @endpoint POST /users/{id}/block
  */
 export function useBlockUser(
-  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 (userId: string): Promise<void> => {
-      const client = getApiClient();
-      await client.post(`/api/v1/users/${userId}/block`);
+      const client = getApiClient()
+      await client.post(`/users/${userId}/block`)
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: userKeys.blocked() });
+      queryClient.invalidateQueries({queryKey: userKeys.blocked()})
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Unblock a user
  *
- * @endpoint DELETE /api/v1/users/{id}/block
+ * @endpoint DELETE /users/{id}/block
  */
 export function useUnblockUser(
-  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 (userId: string): Promise<void> => {
-      const client = getApiClient();
-      await client.delete(`/api/v1/users/${userId}/block`);
+      const client = getApiClient()
+      await client.delete(`/users/${userId}/block`)
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: userKeys.blocked() });
+      queryClient.invalidateQueries({queryKey: userKeys.blocked()})
     },
     ...options,
-  });
+  })
 }

package/src/api/queries/auth.ts

@@ -4,9 +4,19 @@
  * TanStack Query hooks for authentication operations.
  */
 
-import { useMutation, UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
-import { getApiClient } from '../client';
-import type { SendOtpRequest, VerifyOtpRequest, AuthResponse, ApiResponse } from '../types';
+import {
+  useMutation,
+  type UseMutationOptions,
+  type UseMutationResult,
+} from '@tanstack/react-query'
+
+import {getApiClient} from '../client'
+import {
+  type ApiResponse,
+  type AuthResponse,
+  type SendOtpRequest,
+  type VerifyOtpRequest,
+} from '../types'
 
 // ============================================================================
 // MUTATION HOOKS
@@ -15,53 +25,68 @@ import type { SendOtpRequest, VerifyOtpRequest, AuthResponse, ApiResponse } from
 /**
  * Send OTP to phone number
  *
- * @endpoint POST /api/v1/auth/send-otp
+ * @endpoint POST /auth/send-otp
  */
 export function useSendOtp(
-  options?: Omit<UseMutationOptions<ApiResponse<{ sent: boolean }>, Error, SendOtpRequest>, 'mutationFn'>
-): UseMutationResult<ApiResponse<{ sent: boolean }>, Error, SendOtpRequest> {
+  options?: Omit<
+    UseMutationOptions<ApiResponse<{sent: boolean}>, Error, SendOtpRequest>,
+    'mutationFn'
+  >,
+): UseMutationResult<ApiResponse<{sent: boolean}>, Error, SendOtpRequest> {
   return useMutation({
     mutationFn: async (data: SendOtpRequest) => {
-      const client = getApiClient();
-      const response = await client.post<ApiResponse<{ sent: boolean }>>('/api/v1/auth/send-otp', data);
-      return response.data;
+      const client = getApiClient()
+      const response = await client.post<ApiResponse<{sent: boolean}>>(
+        '/auth/send-otp',
+        data,
+      )
+      return response.data
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Verify OTP and authenticate
  *
- * @endpoint POST /api/v1/auth/verify-otp
+ * @endpoint POST /auth/verify-otp
  */
 export function useVerifyOtp(
-  options?: Omit<UseMutationOptions<AuthResponse, Error, VerifyOtpRequest>, 'mutationFn'>
+  options?: Omit<
+    UseMutationOptions<AuthResponse, Error, VerifyOtpRequest>,
+    'mutationFn'
+  >,
 ): UseMutationResult<AuthResponse, Error, VerifyOtpRequest> {
   return useMutation({
     mutationFn: async (data: VerifyOtpRequest) => {
-      const client = getApiClient();
-      const response = await client.post<AuthResponse>('/api/v1/auth/verify-otp', data);
-      return response.data;
+      const client = getApiClient()
+      const response = await client.post<AuthResponse>('/auth/verify-otp', data)
+      return response.data
     },
     ...options,
-  });
+  })
 }
 
 /**
  * Refresh access token
  *
- * @endpoint POST /api/v1/auth/refresh
+ * @endpoint POST /auth/refresh
  */
 export function useRefreshToken(
-  options?: Omit<UseMutationOptions<{ accessToken: string }, Error, { refreshToken: string }>, 'mutationFn'>
-): UseMutationResult<{ accessToken: string }, Error, { refreshToken: string }> {
+  options?: Omit<
+    UseMutationOptions<{accessToken: string}, Error, {refreshToken: string}>,
+    'mutationFn'
+  >,
+): UseMutationResult<{accessToken: string}, Error, {refreshToken: string}> {
   return useMutation({
-    mutationFn: async (data: { refreshToken: string }) => {
-      const client = getApiClient();
-      const response = await client.post<{ accessToken: string }>('/api/v1/auth/refresh', data);
-      return response.data;
+    mutationFn: async (data: {refreshToken: string}) => {
+      const client = getApiClient()
+      const response = await client.post<{accessToken: string}>(
+        '/auth/refresh',
+        data,
+      )
+      return response.data
     },
     ...options,
-  });
+  })
 }

package/src/api/queries/clubs.ts

@@ -4,9 +4,14 @@
  * TanStack Query hooks for club operations.
  */
 
-import { useQuery, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
-import { getApiClient } from '../client';
-import type { Club, ApiResponse } from '../types';
+import {
+  useQuery,
+  type UseQueryOptions,
+  type UseQueryResult,
+} from '@tanstack/react-query'
+
+import {getApiClient} from '../client'
+import {type ApiResponse, type Club} from '../types'
 
 // ============================================================================
 // QUERY KEYS
@@ -19,8 +24,9 @@ export const clubKeys = {
   detail: (id: string) => [...clubKeys.details(), id] as const,
   bySlug: (slug: string) => [...clubKeys.all, 'slug', slug] as const,
   byUser: (userId: string) => [...clubKeys.all, 'user', userId] as const,
-  membership: (clubId: string, userId: string) => [...clubKeys.detail(clubId), 'membership', userId] as const,
-};
+  membership: (clubId: string, userId: string) =>
+    [...clubKeys.detail(clubId), 'membership', userId] as const,
+}
 
 // ============================================================================
 // QUERY HOOKS
@@ -29,107 +35,116 @@ export const clubKeys = {
 /**
  * Get clubs for a spot
  *
- * @endpoint GET /api/v1/clubs/spot/{spotId}
+ * @endpoint GET /clubs/spot/{spotId}
  */
 export function useClubsBySpot(
   spotId: string,
-  options?: Omit<UseQueryOptions<Club[]>, 'queryKey' | 'queryFn'>
+  options?: Omit<UseQueryOptions<Club[]>, 'queryKey' | 'queryFn'>,
 ): UseQueryResult<Club[]> {
   return useQuery({
     queryKey: clubKeys.bySpot(spotId),
     queryFn: async (): Promise<Club[]> => {
-      const client = getApiClient();
-      const response = await client.get<ApiResponse<Club[]>>(`/api/v1/clubs/spot/${spotId}`);
-      return response.data.data;
+      const client = getApiClient()
+      const response = await client.get<ApiResponse<Club[]>>(
+        `/clubs/spot/${spotId}`,
+      )
+      return response.data.data
     },
     enabled: !!spotId,
     ...options,
-  });
+  })
 }
 
 /**
  * Get a club by ID
  *
- * @endpoint GET /api/v1/clubs/{id}
+ * @endpoint GET /clubs/{id}
  */
 export function useClub(
   clubId: string,
-  options?: Omit<UseQueryOptions<Club>, 'queryKey' | 'queryFn'>
+  options?: Omit<UseQueryOptions<Club>, 'queryKey' | 'queryFn'>,
 ): UseQueryResult<Club> {
   return useQuery({
     queryKey: clubKeys.detail(clubId),
     queryFn: async (): Promise<Club> => {
-      const client = getApiClient();
-      const response = await client.get<ApiResponse<Club>>(`/api/v1/clubs/${clubId}`);
-      return response.data.data;
+      const client = getApiClient()
+      const response = await client.get<ApiResponse<Club>>(`/clubs/${clubId}`)
+      return response.data.data
     },
     enabled: !!clubId,
     ...options,
-  });
+  })
 }
 
 /**
  * Get a club by slug
  *
- * @endpoint GET /api/v1/clubs/slug/{slug}
+ * @endpoint GET /clubs/slug/{slug}
  */
 export function useClubBySlug(
   slug: string,
-  options?: Omit<UseQueryOptions<Club>, 'queryKey' | 'queryFn'>
+  options?: Omit<UseQueryOptions<Club>, 'queryKey' | 'queryFn'>,
 ): UseQueryResult<Club> {
   return useQuery({
     queryKey: clubKeys.bySlug(slug),
     queryFn: async (): Promise<Club> => {
-      const client = getApiClient();
-      const response = await client.get<ApiResponse<Club>>(`/api/v1/clubs/slug/${slug}`);
-      return response.data.data;
+      const client = getApiClient()
+      const response = await client.get<ApiResponse<Club>>(
+        `/clubs/slug/${slug}`,
+      )
+      return response.data.data
     },
     enabled: !!slug,
     ...options,
-  });
+  })
 }
 
 /**
  * Get clubs for a user
  *
- * @endpoint GET /api/v1/clubs/user/{userId}
+ * @endpoint GET /clubs/user/{userId}
  */
 export function useClubsByUser(
   userId: string,
-  options?: Omit<UseQueryOptions<Club[]>, 'queryKey' | 'queryFn'>
+  options?: Omit<UseQueryOptions<Club[]>, 'queryKey' | 'queryFn'>,
 ): UseQueryResult<Club[]> {
   return useQuery({
     queryKey: clubKeys.byUser(userId),
     queryFn: async (): Promise<Club[]> => {
-      const client = getApiClient();
-      const response = await client.get<ApiResponse<Club[]>>(`/api/v1/clubs/user/${userId}`);
-      return response.data.data;
+      const client = getApiClient()
+      const response = await client.get<ApiResponse<Club[]>>(
+        `/clubs/user/${userId}`,
+      )
+      return response.data.data
     },
     enabled: !!userId,
     ...options,
-  });
+  })
 }
 
 /**
  * Get membership status for a user in a club
  *
- * @endpoint GET /api/v1/clubs/{id}/membership/{userId}
+ * @endpoint GET /clubs/{id}/membership/{userId}
  */
 export function useClubMembership(
   clubId: string,
   userId: string,
-  options?: Omit<UseQueryOptions<{ isMember: boolean; role?: string }>, 'queryKey' | 'queryFn'>
-): UseQueryResult<{ isMember: boolean; role?: string }> {
+  options?: Omit<
+    UseQueryOptions<{isMember: boolean; role?: string}>,
+    'queryKey' | 'queryFn'
+  >,
+): UseQueryResult<{isMember: boolean; role?: string}> {
   return useQuery({
     queryKey: clubKeys.membership(clubId, userId),
     queryFn: async () => {
-      const client = getApiClient();
-      const response = await client.get<ApiResponse<{ isMember: boolean; role?: string }>>(
-        `/api/v1/clubs/${clubId}/membership/${userId}`
-      );
-      return response.data.data;
+      const client = getApiClient()
+      const response = await client.get<
+        ApiResponse<{isMember: boolean; role?: string}>
+      >(`/clubs/${clubId}/membership/${userId}`)
+      return response.data.data
     },
     enabled: !!clubId && !!userId,
     ...options,
-  });
+  })
 }