@spotsdev/sdk 1.0.0 → 1.2.0

package/src/api/queries/posts.ts

@@ -4,9 +4,70 @@
  * TanStack Query hooks for post/board operations.
  */
 
-import { useQuery, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
-import { getApiClient } from '../client';
-import type { Post, PostResponse, ApiResponse, PostStatusDto } from '../types';
+import {
+  useQuery,
+  type UseQueryOptions,
+  type UseQueryResult,
+} from '@tanstack/react-query'
+
+import {getApiClient} from '../client'
+import {
+  type ApiResponse,
+  type Post,
+  type PostResponse,
+  type PostStatusDto,
+  type PostUpvotesResponse,
+} from '../types'
+
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+
+/**
+ * Extract array data from API response
+ * API returns { success, data: { data: [...], meta: {...} } } or { success, data: [...] }
+ */
+function extractArrayData<T>(data: unknown): T[] {
+  // If already an array, return it
+  if (Array.isArray(data)) {
+    return data
+  }
+  // If it's an object with nested data property, extract it
+  if (data && typeof data === 'object' && 'data' in data) {
+    const nested = (data as {data: unknown}).data
+    if (Array.isArray(nested)) {
+      return nested
+    }
+  }
+  return []
+}
+
+/**
+ * Extract single object data from API response
+ * API returns { success, data: { data: {...} } } or { success, data: {...} }
+ */
+function extractObjectData<T>(data: unknown): T {
+  // If it's an object with nested data property (not an array), extract it
+  if (
+    data &&
+    typeof data === 'object' &&
+    'data' in data &&
+    !Array.isArray(data)
+  ) {
+    const nested = (data as {data: unknown}).data
+    // Check if nested also has a data property (double-wrapped)
+    if (
+      nested &&
+      typeof nested === 'object' &&
+      'data' in nested &&
+      !Array.isArray(nested)
+    ) {
+      return (nested as {data: T}).data
+    }
+    return nested as T
+  }
+  return data as T
+}
 
 // ============================================================================
 // QUERY KEYS
@@ -15,13 +76,18 @@ import type { Post, PostResponse, ApiResponse, PostStatusDto } from '../types';
 export const postKeys = {
   all: ['posts'] as const,
   lists: () => [...postKeys.all, 'list'] as const,
-  list: (filters?: Record<string, unknown>) => [...postKeys.lists(), filters] as const,
-  bySpot: (spotId: string, filters?: Record<string, unknown>) => [...postKeys.all, 'spot', spotId, filters] as const,
+  list: (filters?: Record<string, unknown>) =>
+    [...postKeys.lists(), filters] as const,
+  bySpot: (spotId: string, filters?: Record<string, unknown>) =>
+    [...postKeys.all, 'spot', spotId, filters] as const,
   details: () => [...postKeys.all, 'detail'] as const,
   detail: (id: string) => [...postKeys.details(), id] as const,
-  responses: (postId: string) => [...postKeys.detail(postId), 'responses'] as const,
+  responses: (postId: string) =>
+    [...postKeys.detail(postId), 'responses'] as const,
   status: (postId: string) => [...postKeys.detail(postId), 'status'] as const,
-};
+  upvotes: (postId: string, filters?: {limit?: number; offset?: number}) =>
+    [...postKeys.detail(postId), 'upvotes', filters] as const,
+}
 
 // ============================================================================
 // QUERY HOOKS
@@ -30,113 +96,202 @@ export const postKeys = {
 /**
  * Get posts for a spot
  *
- * @endpoint GET /api/v1/spots/{spotId}/posts
+ * @endpoint GET /spots/{spotId}/posts
  */
 export function useSpotPosts(
   spotId: string,
-  params?: { postType?: string; status?: string; page?: number; limit?: number },
-  options?: Omit<UseQueryOptions<Post[]>, 'queryKey' | 'queryFn'>
+  params?: {postType?: string; status?: string; page?: number; limit?: number},
+  options?: Omit<UseQueryOptions<Post[]>, 'queryKey' | 'queryFn'>,
 ): UseQueryResult<Post[]> {
   return useQuery({
     queryKey: postKeys.bySpot(spotId, params),
     queryFn: async (): Promise<Post[]> => {
-      const client = getApiClient();
-      const queryParams = new URLSearchParams();
-      if (params?.postType) queryParams.set('postType', params.postType);
-      if (params?.status) queryParams.set('status', params.status);
-      if (params?.page) queryParams.set('page', String(params.page));
-      if (params?.limit) queryParams.set('limit', String(params.limit));
-      const response = await client.get<ApiResponse<Post[]>>(`/api/v1/spots/${spotId}/posts?${queryParams}`);
-      return response.data.data;
+      const client = getApiClient()
+      const queryParams = new URLSearchParams()
+      if (params?.postType) queryParams.set('postType', params.postType)
+      if (params?.status) queryParams.set('status', params.status)
+      if (params?.page) queryParams.set('page', String(params.page))
+      if (params?.limit) queryParams.set('limit', String(params.limit))
+      const response = await client.get<ApiResponse<unknown>>(
+        `/spots/${spotId}/posts?${queryParams}`,
+      )
+      return extractArrayData<Post>(response.data.data)
     },
     enabled: !!spotId,
     ...options,
-  });
+  })
 }
 
 /**
  * Get a single post by ID
  *
- * @endpoint GET /api/v1/posts/{postId}
+ * @endpoint GET /posts/{postId}
  */
 export function usePost(
   postId: string,
-  options?: Omit<UseQueryOptions<Post>, 'queryKey' | 'queryFn'>
+  options?: Omit<UseQueryOptions<Post>, 'queryKey' | 'queryFn'>,
 ): UseQueryResult<Post> {
   return useQuery({
     queryKey: postKeys.detail(postId),
     queryFn: async (): Promise<Post> => {
-      const client = getApiClient();
-      const response = await client.get<ApiResponse<Post>>(`/api/v1/posts/${postId}`);
-      return response.data.data;
+      const client = getApiClient()
+      const response = await client.get<ApiResponse<unknown>>(
+        `/posts/${postId}`,
+      )
+      return extractObjectData<Post>(response.data.data)
     },
     enabled: !!postId,
     ...options,
-  });
+  })
 }
 
 /**
  * Get responses for a post
  *
- * @endpoint GET /api/v1/posts/{postId}/responses
+ * @endpoint GET /posts/{postId}/responses
  */
 export function usePostResponses(
   postId: string,
-  options?: Omit<UseQueryOptions<PostResponse[]>, 'queryKey' | 'queryFn'>
+  options?: Omit<UseQueryOptions<PostResponse[]>, 'queryKey' | 'queryFn'>,
 ): UseQueryResult<PostResponse[]> {
   return useQuery({
     queryKey: postKeys.responses(postId),
     queryFn: async (): Promise<PostResponse[]> => {
-      const client = getApiClient();
-      const response = await client.get<ApiResponse<PostResponse[]>>(`/api/v1/posts/${postId}/responses`);
-      return response.data.data;
+      const client = getApiClient()
+      const response = await client.get<ApiResponse<unknown>>(
+        `/posts/${postId}/responses`,
+      )
+      return extractArrayData<PostResponse>(response.data.data)
     },
     enabled: !!postId,
     ...options,
-  });
+  })
 }
 
 /**
  * Get all posts (with filters)
  *
- * @endpoint GET /api/v1/posts
+ * @endpoint GET /posts
  */
 export function usePosts(
-  params?: { postType?: string; limit?: number },
-  options?: Omit<UseQueryOptions<Post[]>, 'queryKey' | 'queryFn'>
+  params?: {postType?: string; limit?: number},
+  options?: Omit<UseQueryOptions<Post[]>, 'queryKey' | 'queryFn'>,
 ): UseQueryResult<Post[]> {
   return useQuery({
     queryKey: postKeys.list(params),
     queryFn: async (): Promise<Post[]> => {
-      const client = getApiClient();
-      const queryParams = new URLSearchParams();
-      if (params?.postType) queryParams.set('postType', params.postType);
-      if (params?.limit) queryParams.set('limit', String(params.limit));
-      const response = await client.get<ApiResponse<Post[]>>(`/api/v1/posts?${queryParams}`);
-      return response.data.data;
+      const client = getApiClient()
+      const queryParams = new URLSearchParams()
+      if (params?.postType) queryParams.set('postType', params.postType)
+      if (params?.limit) queryParams.set('limit', String(params.limit))
+      const response = await client.get<ApiResponse<unknown>>(
+        `/posts?${queryParams}`,
+      )
+      return extractArrayData<Post>(response.data.data)
     },
     ...options,
-  });
+  })
 }
 
-
 /**
  * Get user's status for a post (read/hidden/pinned)
  *
- * @endpoint GET /api/v1/posts/{postId}/status
+ * @endpoint GET /posts/{postId}/status
  */
 export function usePostStatus(
   postId: string,
-  options?: Omit<UseQueryOptions<PostStatusDto>, 'queryKey' | 'queryFn'>
+  options?: Omit<UseQueryOptions<PostStatusDto>, 'queryKey' | 'queryFn'>,
 ): UseQueryResult<PostStatusDto> {
   return useQuery({
     queryKey: postKeys.status(postId),
     queryFn: async (): Promise<PostStatusDto> => {
-      const client = getApiClient();
-      const response = await client.get<ApiResponse<PostStatusDto>>(`/api/v1/posts/${postId}/status`);
-      return response.data.data;
+      const client = getApiClient()
+      const response = await client.get<ApiResponse<unknown>>(
+        `/posts/${postId}/status`,
+      )
+      return extractObjectData<PostStatusDto>(response.data.data)
+    },
+    enabled: !!postId,
+    ...options,
+  })
+}
+
+/**
+ * Get upvotes for a post (list of users who upvoted)
+ *
+ * @endpoint GET /posts/{postId}/upvotes
+ */
+export function usePostUpvotes(
+  postId: string,
+  params?: {limit?: number; offset?: number},
+  options?: Omit<UseQueryOptions<PostUpvotesResponse>, 'queryKey' | 'queryFn'>,
+): UseQueryResult<PostUpvotesResponse> {
+  return useQuery({
+    queryKey: postKeys.upvotes(postId, params),
+    queryFn: async (): Promise<PostUpvotesResponse> => {
+      const client = getApiClient()
+      const queryParams = new URLSearchParams()
+      if (params?.limit) queryParams.set('limit', String(params.limit))
+      if (params?.offset) queryParams.set('offset', String(params.offset))
+      const queryString = queryParams.toString()
+      const response = await client.get<ApiResponse<PostUpvotesResponse>>(
+        `/posts/${postId}/upvotes${queryString ? `?${queryString}` : ''}`,
+      )
+      // Response structure: { success, data: { data: [...], meta: {...} } }
+      return response.data.data
     },
     enabled: !!postId,
     ...options,
-  });
+  })
+}
+
+/**
+ * Get nearby posts feed
+ *
+ * @endpoint GET /posts/feed
+ */
+export function usePostsFeed(
+  params: {
+    lat: number
+    lng: number
+    radius?: number
+    postType?: string
+    cursor?: string
+    limit?: number
+  },
+  options?: Omit<
+    UseQueryOptions<{posts: Post[]; hasMore: boolean; nextCursor?: string}>,
+    'queryKey' | 'queryFn'
+  >,
+): UseQueryResult<{posts: Post[]; hasMore: boolean; nextCursor?: string}> {
+  return useQuery({
+    queryKey: [...postKeys.lists(), 'feed', params] as const,
+    queryFn: async (): Promise<{
+      posts: Post[]
+      hasMore: boolean
+      nextCursor?: string
+    }> => {
+      const client = getApiClient()
+      const queryParams = new URLSearchParams()
+      queryParams.set('lat', String(params.lat))
+      queryParams.set('lng', String(params.lng))
+      if (params.radius) queryParams.set('radius', String(params.radius))
+      if (params.postType) queryParams.set('postType', params.postType)
+      if (params.cursor) queryParams.set('cursor', params.cursor)
+      if (params.limit) queryParams.set('limit', String(params.limit))
+
+      const response = await client.get<
+        ApiResponse<{posts: Post[]; hasMore: boolean; nextCursor?: string}>
+      >(`/posts/feed?${queryParams}`)
+
+      const data = response.data.data
+      return {
+        posts: data.posts ?? extractArrayData<Post>(data),
+        hasMore: data.hasMore ?? false,
+        nextCursor: data.nextCursor,
+      }
+    },
+    enabled: params.lat !== 0 && params.lng !== 0,
+    ...options,
+  })
 }

package/src/api/queries/products.ts

@@ -4,9 +4,16 @@
  * TanStack Query hooks for product-related operations.
  */
 
-import { useQuery, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
-import { getApiClient } from '../client';
-import type { Product, ApiResponse, PaginatedResponse, ProductType, ProductStatus } from '../types';
+import {useQuery, type UseQueryOptions, type UseQueryResult} from '@tanstack/react-query'
+import {getApiClient} from '../client'
+import type {
+  Product,
+  ApiResponse,
+  PaginatedResponse,
+  ProductType,
+  ProductStatus,
+  Spot,
+} from '../types'
 
 // ============================================================================
 // QUERY KEYS
@@ -15,31 +22,29 @@ import type { Product, ApiResponse, PaginatedResponse, ProductType, ProductStatu
 export const productKeys = {
   all: ['products'] as const,
   lists: () => [...productKeys.all, 'list'] as const,
-  list: (filters?: Record<string, unknown>) => [...productKeys.lists(), filters] as const,
+  list: (filters?: Record<string, unknown>) =>
+    [...productKeys.lists(), filters] as const,
   details: () => [...productKeys.all, 'detail'] as const,
   detail: (id: string) => [...productKeys.details(), id] as const,
-  bySlug: (spotId: string, slug: string) => [...productKeys.all, 'slug', spotId, slug] as const,
+  bySlug: (spotId: string, slug: string) =>
+    [...productKeys.all, 'slug', spotId, slug] as const,
   bySpot: (spotId: string) => [...productKeys.all, 'spot', spotId] as const,
-};
+}
 
 // ============================================================================
 // TYPES
 // ============================================================================
 
 export interface ProductFilters {
-  spotId?: string;
-  type?: ProductType;
-  status?: ProductStatus;
-  limit?: number;
-  page?: number;
+  spotId?: string
+  type?: ProductType
+  status?: ProductStatus
+  limit?: number
+  page?: number
 }
 
 export interface ProductWithSpot extends Product {
-  spot: {
-    id: string;
-    name: string;
-    slug: string;
-  };
+  spot: Pick<Spot, 'id' | 'name' | 'slug'>
 }
 
 // ============================================================================
@@ -49,75 +54,77 @@ export interface ProductWithSpot extends Product {
 /**
  * Get products for a spot (public browse)
  *
- * @endpoint GET /api/v1/spots/{spotId}/products
+ * @endpoint GET /spots/{spotId}/products
  */
 export function useSpotProducts(
   spotId: string,
-  params?: { type?: ProductType; limit?: number; page?: number },
-  options?: Omit<UseQueryOptions<PaginatedResponse<Product>>, 'queryKey' | 'queryFn'>
+  params?: {type?: ProductType; limit?: number; page?: number},
+  options?: Omit<
+    UseQueryOptions<PaginatedResponse<Product>>,
+    'queryKey' | 'queryFn'
+  >,
 ): UseQueryResult<PaginatedResponse<Product>> {
   return useQuery({
     queryKey: productKeys.bySpot(spotId),
     queryFn: async (): Promise<PaginatedResponse<Product>> => {
-      const client = getApiClient();
-      const queryParams = new URLSearchParams();
-      if (params?.limit) queryParams.set('limit', String(params.limit));
-      if (params?.page) queryParams.set('page', String(params.page));
-      if (params?.type) queryParams.set('type', params.type);
+      const client = getApiClient()
+      const queryParams = new URLSearchParams()
+      if (params?.limit) queryParams.set('limit', String(params.limit))
+      if (params?.page) queryParams.set('page', String(params.page))
+      if (params?.type) queryParams.set('type', params.type)
       const response = await client.get<ApiResponse<PaginatedResponse<Product>>>(
-        `/api/v1/spots/${spotId}/products?${queryParams}`
-      );
-      return response.data.data;
+        `/spots/${spotId}/products?${queryParams}`,
+      )
+      return response.data.data
     },
     enabled: !!spotId,
     ...options,
-  });
+  })
 }
 
 /**
  * Get a product by ID
  *
- * @endpoint GET /api/v1/products/{productId}
+ * @endpoint GET /products/{productId}
  */
 export function useProduct(
   productId: string,
-  options?: Omit<UseQueryOptions<ProductWithSpot>, 'queryKey' | 'queryFn'>
+  options?: Omit<UseQueryOptions<ProductWithSpot>, 'queryKey' | 'queryFn'>,
 ): UseQueryResult<ProductWithSpot> {
   return useQuery({
     queryKey: productKeys.detail(productId),
     queryFn: async (): Promise<ProductWithSpot> => {
-      const client = getApiClient();
-      const response = await client.get<ApiResponse<ProductWithSpot>>(`/api/v1/products/${productId}`);
-      return response.data.data;
+      const client = getApiClient()
+      const response = await client.get<ApiResponse<ProductWithSpot>>(
+        `/products/${productId}`,
+      )
+      return response.data.data
     },
     enabled: !!productId,
     ...options,
-  });
+  })
 }
 
 /**
  * Get a product by slug (within a spot)
  *
- * @endpoint GET /api/v1/spots/{spotId}/products/slug/{slug}
+ * @endpoint GET /spots/{spotId}/products/slug/{slug}
  */
 export function useProductBySlug(
   spotId: string,
   slug: string,
-  options?: Omit<UseQueryOptions<ProductWithSpot>, 'queryKey' | 'queryFn'>
+  options?: Omit<UseQueryOptions<ProductWithSpot>, 'queryKey' | 'queryFn'>,
 ): UseQueryResult<ProductWithSpot> {
   return useQuery({
     queryKey: productKeys.bySlug(spotId, slug),
     queryFn: async (): Promise<ProductWithSpot> => {
-      const client = getApiClient();
+      const client = getApiClient()
       const response = await client.get<ApiResponse<ProductWithSpot>>(
-        `/api/v1/spots/${spotId}/products/slug/${slug}`
-      );
-      return response.data.data;
+        `/spots/${spotId}/products/slug/${slug}`,
+      )
+      return response.data.data
     },
     enabled: !!spotId && !!slug,
     ...options,
-  });
+  })
 }
-
-// Note: To list products as a seller, use useSpotProducts with your spot ID.
-// There is no cross-spot product listing endpoint currently.