develp branch 작업내용 머지 : develop -> main

.gitignore

@@ -23,3 +23,6 @@ dist-ssr
 *.njsproj
 *.sln
 *.sw?
+
+# Claude Code documentation
+CLAUDE.md

src/api/books/getSavedBooksInMy.ts

@@ -0,0 +1,43 @@
+import { apiClient } from '../index';
+
+// 개인적으로 저장한 책 정보 타입
+export interface SavedBookInMy {
+  bookId: number;
+  bookTitle: string;
+  authorName: string;
+  publisher: string;
+  bookImageUrl: string;
+  isbn: string;
+  isSaved: boolean;
+}
+
+// API 응답 데이터 타입
+export interface SavedBooksInMyData {
+  bookList: SavedBookInMy[];
+}
+
+// API 응답 타입
+export interface SavedBooksInMyResponse {
+  isSuccess: boolean;
+  code: number;
+  message: string;
+  data: SavedBooksInMyData;
+}
+
+// 개인적으로 저장한 책 목록 조회 API 함수
+export const getSavedBooksInMy = async () => {
+  try {
+    const response = await apiClient.get<SavedBooksInMyResponse>('/books/saved');
+    return response.data;
+  } catch (error) {
+    console.error('개인 저장 책 조회 API 오류:', error);
+    throw error;
+  }
+};
+
+/*
+// 사용 예시
+const savedBooksInMy = await getSavedBooksInMy();
+console.log(savedBooksInMy.data.bookList); // 개인 저장 책 목록
+console.log(savedBooksInMy.data.bookList[0].bookTitle); // 첫 번째 책 제목
+*/

src/api/books/getSearchBooks.ts

@@ -58,9 +58,9 @@ export const getSearchBooks = async (
   }
 };
 
-export const convertToSearchedBooks = (apiBooks: BookSearchItem[]): SearchedBook[] => {
+export const convertToSearchedBooks = (apiBooks: BookSearchItem[], startIndex: number = 0): SearchedBook[] => {
   return apiBooks.map((book, index) => ({
-    id: index + 1,
+    id: startIndex + index + 1,
     title: book.title,
     author: book.authorName,
     publisher: book.publisher,

src/api/feeds/getFeedsByIsbn.ts

@@ -0,0 +1,48 @@
+import { apiClient } from '@/api/index';
+
+export type FeedSort = 'like' | 'latest';
+
+export interface FeedItem {
+  feedId: number;
+  creatorId: number;
+  isWriter: boolean;
+  creatorNickname: string;
+  creatorProfileImageUrl: string;
+  aliasName: string;
+  aliasColor: string;
+  postDate: string;
+  isbn: string;
+  bookTitle: string;
+  bookAuthor: string;
+  contentBody: string;
+  contentUrls: string[];
+  likeCount: number;
+  commentCount: number;
+  isSaved: boolean;
+  isLiked: boolean;
+}
+
+export interface GetFeedsByIsbnResponse {
+  isSuccess: boolean;
+  code: number;
+  message: string;
+  data: {
+    feeds: FeedItem[];
+    nextCursor: string | null;
+    isLast: boolean;
+  };
+}
+
+export const getFeedsByIsbn = async (
+  isbn: string,
+  sort: FeedSort = 'like',
+  cursor?: string | null,
+): Promise<GetFeedsByIsbnResponse> => {
+  const params = new URLSearchParams();
+  params.set('sort', sort);
+  if (cursor != null) params.set('cursor', cursor);
+
+  const url = `/feeds/related-books/${encodeURIComponent(isbn)}?` + params.toString();
+  const res = await apiClient.get<GetFeedsByIsbnResponse>(url);
+  return res.data;
+};

src/api/feeds/getSavedFeedsInMy.ts

@@ -0,0 +1,68 @@
+import { apiClient } from '../index';
+
+// 개인적으로 저장한 피드 정보 타입
+export interface SavedFeedInMy {
+  feedId: number;
+  creatorId: number;
+  creatorNickname: string;
+  creatorProfileImageUrl: string;
+  aliasName: string;
+  aliasColor: string;
+  postDate: string;
+  isbn: string;
+  bookTitle: string;
+  bookAuthor: string;
+  contentBody: string;
+  contentUrls: string[];
+  likeCount: number;
+  commentCount: number;
+  isSaved: boolean;
+  isLiked: boolean;
+  isWriter: boolean;
+}
+
+// API 응답 데이터 타입 (무한스크롤 지원)
+export interface SavedFeedsInMyData {
+  feedList: SavedFeedInMy[];
+  nextCursor: string;
+  isLast: boolean;
+}
+
+// API 응답 타입
+export interface SavedFeedsInMyResponse {
+  isSuccess: boolean;
+  code: number;
+  message: string;
+  data: SavedFeedsInMyData;
+}
+
+// 개인적으로 저장한 피드 목록 조회 API 함수 (무한스크롤)
+export const getSavedFeedsInMy = async (cursor: string | null = null) => {
+  try {
+    const params: { cursor?: string | null } = {};
+    if (cursor !== null) {
+      params.cursor = cursor;
+    }
+
+    const response = await apiClient.get<SavedFeedsInMyResponse>('/feeds/saved', {
+      params,
+    });
+    return response.data;
+  } catch (error) {
+    console.error('개인 저장 피드 조회 API 오류:', error);
+    throw error;
+  }
+};
+
+/*
+// 사용 예시 (무한스크롤)
+const savedFeedsInMy = await getSavedFeedsInMy();
+console.log(savedFeedsInMy.data.feedList); // 저장된 피드 목록
+console.log(savedFeedsInMy.data.nextCursor); // 다음 페이지 커서
+console.log(savedFeedsInMy.data.isLast); // 마지막 페이지 여부
+
+// 다음 페이지 로드
+if (!savedFeedsInMy.data.isLast) {
+  const nextPage = await getSavedFeedsInMy(savedFeedsInMy.data.nextCursor);
+}
+*/

src/api/recentsearch/deleteRecentSearch.ts

@@ -10,11 +10,10 @@ export interface DeleteRecentSearchResponse {
 
 export const deleteRecentSearch = async (
   recentSearchId: number,
-  userId: number,
 ): Promise<DeleteRecentSearchResponse> => {
   try {
     const response = await apiClient.delete<DeleteRecentSearchResponse>(
-      `/recent-searches/${recentSearchId}?userId=${userId}`,
+      `/recent-searches/${recentSearchId}`,
     );
     return response.data;
   } catch (error) {

src/api/record/index.ts

@@ -0,0 +1,6 @@
+export * from './createRecord';
+export * from './createVote';
+export * from './deleteRecord';
+export * from './deleteVote';
+export * from './postVote';
+export * from './pinRecordToFeed';

src/api/record/pinRecordToFeed.ts

@@ -0,0 +1,41 @@
+import { apiClient } from '../index';
+import type { ApiResponse } from '@/types/record';
+
+// 피드 핀 응답 데이터 타입
+export interface PinRecordData {
+  bookTitle: string;
+  authorName: string;
+  bookImageUrl: string;
+  isbn: string;
+}
+
+// API 응답 타입
+export type PinRecordResponse = ApiResponse<PinRecordData>;
+
+// 기록을 피드에 핀하기 API 함수
+export const pinRecordToFeed = async (roomId: number, recordId: number) => {
+  const response = await apiClient.get<PinRecordResponse>(
+    `/rooms/${roomId}/records/${recordId}/pin`
+  );
+  return response.data;
+};
+
+/*
+사용 예시:
+try {
+  const result = await pinRecordToFeed(1, 123);
+  if (result.isSuccess) {
+    console.log("책 제목:", result.data.bookTitle);
+    console.log("저자명:", result.data.authorName);
+    console.log("책 이미지:", result.data.bookImageUrl);
+    console.log("ISBN:", result.data.isbn);
+    // 성공 처리 로직 - 피드 작성 화면으로 이동
+  } else {
+    console.error("핀하기 실패:", result.message);
+    // 실패 처리 로직
+  }
+} catch (error) {
+  console.error("API 호출 오류:", error);
+  // 에러 처리 로직
+}
+*/

src/api/record/postVote.ts

@@ -0,0 +1,38 @@
+import { apiClient } from '../index';
+import type { VoteRequest, VoteData, ApiResponse } from '@/types/record';
+
+// API 응답 타입
+export type VoteResponse = ApiResponse<VoteData>;
+
+// 투표하기 API 함수
+export const postVote = async (roomId: number, voteId: number, voteData: VoteRequest) => {
+  const response = await apiClient.post<VoteResponse>(`/rooms/${roomId}/vote/${voteId}`, voteData);
+  return response.data;
+};
+
+/*
+사용 예시:
+const voteData: VoteRequest = {
+  voteItemId: 1,
+  type: true // true: 투표하기, false: 투표취소
+};
+
+try {
+  const result = await postVote(1, 1, voteData);
+  if (result.isSuccess) {
+    console.log("투표 성공:", result.data);
+    console.log("포스트 ID:", result.data.postId);
+    console.log("방 ID:", result.data.roomId);
+    console.log("투표 결과:", result.data.voteItems);
+    // 성공 처리 로직
+  } else {
+    console.error("투표 실패:", result.message);
+    // 실패 처리 로직 (에러 코드별 분기 처리 가능)
+    // 120001: 이미 투표한 투표항목입니다.
+    // 120002: 투표하지 않은 투표항목은 취소할 수 없습니다.
+  }
+} catch (error) {
+  console.error("API 호출 오류:", error);
+  // 에러 처리 로직
+}
+*/

src/components/common/BookSearchBottomSheet/BookList.tsx

@@ -1,9 +1,12 @@
+import { useEffect, useRef, useCallback } from 'react';
 import {
   BookList as StyledBookList,
   BookItem,
   BookCover,
   BookInfo,
   BookTitle,
+  LoadingContainer,
+  LoadingText,
 } from './BookSearchBottomSheet.styled';
 
 export interface Book {
@@ -17,17 +20,58 @@ export interface Book {
 interface BookListProps {
   books: Book[];
   onBookSelect: (book: Book) => void;
+  onLoadMore?: () => Promise<void>;
+  hasNextPage?: boolean;
+  isLoadingMore?: boolean;
+  isSearchMode?: boolean;
 }
 
-const BookList = ({ books, onBookSelect }: BookListProps) => {
+const BookList = ({ 
+  books, 
+  onBookSelect, 
+  onLoadMore, 
+  hasNextPage = false, 
+  isLoadingMore = false,
+  isSearchMode = false 
+}: BookListProps) => {
+  const observerRef = useRef<IntersectionObserver | null>(null);
+  const loadingRef = useRef<HTMLDivElement | null>(null);
+
   const handleImageError = (e: React.SyntheticEvent<HTMLImageElement>) => {
     e.currentTarget.style.display = 'none';
   };
 
+  // 무한스크롤을 위한 Intersection Observer 설정
+  const lastBookElementRef = useCallback((node: HTMLDivElement | null) => {
+    if (isLoadingMore) return;
+
+    if (observerRef.current) observerRef.current.disconnect();
+
+    observerRef.current = new IntersectionObserver(entries => {
+      if (entries[0].isIntersecting && hasNextPage && onLoadMore && isSearchMode) {
+        onLoadMore();
+      }
+    });
+
+    if (node) observerRef.current.observe(node);
+  }, [isLoadingMore, hasNextPage, onLoadMore, isSearchMode]);
+
+  useEffect(() => {
+    return () => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+      }
+    };
+  }, []);
+
   return (
     <StyledBookList>
-      {books.map(book => (
-        <BookItem key={book.id} onClick={() => onBookSelect(book)}>
+      {books.map((book, index) => (
+        <BookItem 
+          key={`${book.id}-${book.isbn}`} 
+          onClick={() => onBookSelect(book)}
+          ref={index === books.length - 1 ? lastBookElementRef : null}
+        >
           <BookCover>
             <img src={book.cover} alt={book.title} onError={handleImageError} />
           </BookCover>
@@ -36,6 +80,13 @@ const BookList = ({ books, onBookSelect }: BookListProps) => {
           </BookInfo>
         </BookItem>
       ))}
+
+      {/* 검색 모드에서 더 많은 데이터가 있고 로딩 중일 때 로딩 표시 */}
+      {isSearchMode && isLoadingMore && (
+        <LoadingContainer ref={loadingRef}>
+          <LoadingText>더 많은 책을 불러오는 중...</LoadingText>
+        </LoadingContainer>
+      )}
     </StyledBookList>
   );
 };