Merge pull request #105 from LimSB-dev/canary

canary to master (v2.0.0)

Author: LimSB-dev

auth.config.ts

@@ -6,7 +6,6 @@ export const authConfig = {
   },
   callbacks: {
     authorized({ auth, request: { nextUrl } }) {
-      console.log('authorized', auth, nextUrl);
       const isLoggedIn = !!auth?.user;
       const isOnDashboard = nextUrl.pathname.startsWith('/dashboard');
 

auth.ts

@@ -18,15 +18,21 @@ export const {
   callbacks: {
     async signIn({ user }) {
       try {
-        console.log(user);
+        // 사용자 로그인 처리
         return true;
       } catch (error) {
         console.error("Error handling signIn:", error);
-        return false; // 에러가 발생해도 세션을 반환합니다.
+        return false;
       }
     },
     async session({ session }) {
       try {
+        // 이메일이 없으면 세션을 반환하지 않음
+        if (!session?.user?.email) {
+          console.error("Session callback - No email in session:", session);
+          return session;
+        }
+
         const userEmail = session.user.email;
         const userName = session.user.name || "Unknown";
         const userImage = session.user.image || null;

scripts/seed.js

@@ -96,11 +96,43 @@ async function seedPosts(client) {
   }
 }
 
+async function seedComments(client) {
+  try {
+    await client.query('CREATE EXTENSION IF NOT EXISTS "uuid-ossp"');
+
+    // Create the "comments" table if it doesn't exist
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS comments (
+        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        post_id UUID NOT NULL REFERENCES posts(id) ON DELETE CASCADE,
+        user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+        content TEXT NOT NULL,
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        deleted_at TIMESTAMP DEFAULT NULL
+      )
+    `);
+
+    // 인덱스 생성
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_comments_post_id ON comments(post_id);
+      CREATE INDEX IF NOT EXISTS idx_comments_user_id ON comments(user_id);
+      CREATE INDEX IF NOT EXISTS idx_comments_created_at ON comments(created_at);
+    `);
+
+    console.log(`Created "comments" table`);
+  } catch (error) {
+    console.error("Error seeding comments:", error);
+    throw error;
+  }
+}
+
 async function main() {
   const client = await db.connect();
   console.log("Connected to the database");
   await seedUsers(client);
   await seedPosts(client);
+  await seedComments(client);
 
   await client.end();
 }

src/app/api/auth/[...nextauth]/route.ts

@@ -1,3 +1,3 @@
-export { GET, POST } from "../../../../../auth";
+export { GET, POST } from "@/auth";
 
 export const runtime = "edge";

src/app/api/comments/deleteComment.ts

@@ -0,0 +1,72 @@
+"use server";
+
+import { sql } from "@vercel/postgres";
+import { unstable_noStore as noStore, revalidatePath } from "next/cache";
+import { auth } from "@/auth";
+import { ensureCommentsTable } from "@/utils/ensureCommentsTable";
+
+/**
+ * 댓글을 삭제합니다 (soft delete).
+ * @param commentId 댓글 ID
+ */
+export async function deleteComment(commentId: string): Promise<void> {
+  noStore();
+
+  // 인증 체크
+  const session = await auth();
+  console.log("session", session);
+  if (!session?.user) {
+    throw new Error("Unauthorized: 로그인이 필요합니다.");
+  }
+
+  const userEmail = session.user.email;
+  if (!userEmail) {
+    throw new Error("Unauthorized: 사용자 이메일 정보를 찾을 수 없습니다.");
+  }
+
+  try {
+    // 테이블이 없으면 생성
+    await ensureCommentsTable();
+
+    // 사용자 ID 가져오기
+    const { rows: userRows } = await sql`
+      SELECT id FROM users WHERE email = ${userEmail}
+    `;
+
+    if (!userRows[0]) {
+      throw new Error("사용자 정보를 찾을 수 없습니다.");
+    }
+
+    const userId = userRows[0].id;
+
+    // 댓글 소유권 확인 및 삭제
+    const { rows: commentRows } = await sql`
+      UPDATE comments
+      SET deleted_at = CURRENT_TIMESTAMP
+      WHERE id = ${commentId} 
+        AND user_id = ${userId}
+        AND deleted_at IS NULL
+      RETURNING post_id
+    `;
+
+    if (!commentRows[0]) {
+      throw new Error("댓글을 찾을 수 없거나 삭제 권한이 없습니다.");
+    }
+
+    // 게시글 index 가져오기
+    const { rows: postRows } = await sql`
+      SELECT index FROM posts WHERE id = ${commentRows[0].post_id}
+    `;
+
+    if (postRows[0]) {
+      revalidatePath(`/posts/${postRows[0].index}`);
+    }
+  } catch (error) {
+    console.error("Database Error:", error);
+    throw new Error(
+      error instanceof Error
+        ? error.message
+        : "댓글 삭제 중 오류가 발생했습니다."
+    );
+  }
+}

src/app/api/comments/getComments.ts

@@ -0,0 +1,66 @@
+"use server";
+
+import { sql } from "@vercel/postgres";
+import { unstable_noStore as noStore } from "next/cache";
+import camelcaseKeys from "camelcase-keys";
+import { ensureCommentsTable } from "@/utils/ensureCommentsTable";
+
+/**
+ * 특정 게시글의 댓글 목록을 가져옵니다.
+ * @param postIndex 게시글의 index
+ * @param limit 가져올 댓글 개수 (기본값: 20)
+ * @param offset 건너뛸 댓글 개수 (기본값: 0)
+ * @returns 댓글 목록
+ */
+export async function getComments(
+  postIndex: number,
+  limit: number = 5,
+  offset: number = 0
+): Promise<IComment[]> {
+  noStore();
+
+  try {
+    // 테이블이 없으면 생성
+    await ensureCommentsTable();
+
+    // 먼저 게시글 ID를 가져옵니다
+    const { rows: postRows } = await sql`
+      SELECT id FROM posts WHERE index = ${postIndex} AND status = 'published'
+    `;
+
+    if (!postRows[0]) {
+      return [];
+    }
+
+    const postId = postRows[0].id;
+
+    // 댓글을 가져오면서 사용자 정보도 함께 조인 (최신순 정렬)
+    const { rows } = await sql`
+      SELECT 
+        c.id,
+        c.post_id as "postId",
+        p.index as "postIndex",
+        c.user_id as "userId",
+        u.email as "userEmail",
+        u.name as "userName",
+        u.image as "userImage",
+        c.content,
+        c.created_at as "createdAt",
+        c.updated_at as "updatedAt",
+        c.deleted_at as "deletedAt"
+      FROM comments c
+      INNER JOIN posts p ON c.post_id = p.id
+      LEFT JOIN users u ON c.user_id = u.id
+      WHERE c.post_id = ${postId} AND c.deleted_at IS NULL
+      ORDER BY c.created_at DESC
+      LIMIT ${limit}
+      OFFSET ${offset}
+    `;
+
+    return camelcaseKeys(rows, { deep: true }) as IComment[];
+  } catch (error) {
+    console.error("Database Error:", error);
+    // 테이블이 없거나 에러가 발생하면 빈 배열 반환
+    return [];
+  }
+}

src/app/api/comments/index.ts

@@ -0,0 +1,4 @@
+export { getComments } from "./getComments";
+export { postComment } from "./postComment";
+export { putComment } from "./putComment";
+export { deleteComment } from "./deleteComment";

src/app/api/comments/postComment.ts

@@ -0,0 +1,112 @@
+"use server";
+
+import { sql } from "@vercel/postgres";
+import { unstable_noStore as noStore, revalidatePath } from "next/cache";
+import { auth } from "@/auth";
+import camelcaseKeys from "camelcase-keys";
+import { ensureCommentsTable } from "@/utils/ensureCommentsTable";
+
+/**
+ * 댓글을 생성합니다.
+ * @param postIndex 게시글의 index
+ * @param content 댓글 내용
+ */
+export async function postComment({
+  postIndex,
+  content,
+}: {
+  postIndex: number;
+  content: string;
+}): Promise<IComment> {
+  noStore();
+
+  // 인증 체크
+  const session = await auth();
+  console.log("session", session);
+  if (!session?.user) {
+    throw new Error("Unauthorized: 로그인이 필요합니다.");
+  }
+
+  // 이메일이 없으면 에러
+  const userEmail = session.user.email;
+  if (!userEmail) {
+    throw new Error("Unauthorized: 사용자 이메일 정보를 찾을 수 없습니다.");
+  }
+
+  // 입력 검증
+  if (!content || !content.trim()) {
+    throw new Error("댓글 내용을 입력해주세요.");
+  }
+
+  try {
+    // 테이블이 없으면 생성
+    await ensureCommentsTable();
+
+    // 게시글 ID 가져오기
+    const { rows: postRows } = await sql`
+      SELECT id FROM posts WHERE index = ${postIndex} AND status = 'published'
+    `;
+
+    if (!postRows[0]) {
+      throw new Error("게시글을 찾을 수 없습니다.");
+    }
+
+    const postId = postRows[0].id;
+
+    // 사용자 ID 가져오기
+    const { rows: userRows } = await sql`
+      SELECT id FROM users WHERE email = ${userEmail}
+    `;
+
+    if (!userRows[0]) {
+      throw new Error("사용자 정보를 찾을 수 없습니다.");
+    }
+
+    const userId = userRows[0].id;
+
+    // 댓글 생성
+    const { rows } = await sql`
+      INSERT INTO comments (post_id, user_id, content)
+      VALUES (${postId}, ${userId}, ${content.trim()})
+      RETURNING 
+        id,
+        post_id as "postId",
+        user_id as "userId",
+        content,
+        created_at as "createdAt",
+        updated_at as "updatedAt",
+        deleted_at as "deletedAt"
+    `;
+
+    // 사용자 정보 조인하여 반환
+    const { rows: commentWithUser } = await sql`
+      SELECT 
+        c.id,
+        c.post_id as "postId",
+        p.index as "postIndex",
+        c.user_id as "userId",
+        u.email as "userEmail",
+        u.name as "userName",
+        u.image as "userImage",
+        c.content,
+        c.created_at as "createdAt",
+        c.updated_at as "updatedAt",
+        c.deleted_at as "deletedAt"
+      FROM comments c
+      INNER JOIN posts p ON c.post_id = p.id
+      LEFT JOIN users u ON c.user_id = u.id
+      WHERE c.id = ${rows[0].id}
+    `;
+
+    revalidatePath(`/posts/${postIndex}`);
+
+    return camelcaseKeys(commentWithUser[0], { deep: true }) as IComment;
+  } catch (error) {
+    console.error("Database Error:", error);
+    throw new Error(
+      error instanceof Error
+        ? error.message
+        : "댓글 작성 중 오류가 발생했습니다."
+    );
+  }
+}