create-entity-app-server 0.0.3

package/src/app/routes/board/handlers/posts.ts

@@ -0,0 +1,577 @@
+import type { FastifyRequest, FastifyReply } from "fastify";
+import jwt from "jsonwebtoken";
+import { ok, fail, entityServer } from "@gateway/api";
+import { env } from "@system/config/env.ts";
+import {
+    hashPassword,
+    verifyPassword,
+} from "../../password-reset/password-utils.ts";
+import { setPostTags } from "./tags.ts";
+
+const MENTION_PATTERN = /@([a-zA-Z0-9_]+)/g;
+
+// ── 목록 조회 ────────────────────────────────────────────────────────────────
+
+export async function list(
+    req: FastifyRequest<{
+        Params: { category: string };
+        Querystring: {
+            page?: number;
+            per_page?: number;
+            search?: string;
+            sort?: string;
+            order?: "asc" | "desc";
+            pinned?: string;
+            root_seq?: number;
+            depth?: number;
+            status?: string;
+        };
+    }>,
+    reply: FastifyReply,
+) {
+    const { category } = req.params;
+    const {
+        page = 1,
+        per_page = 20,
+        search,
+        sort = "created_time",
+        order = "desc",
+        pinned,
+        root_seq,
+        depth,
+        status,
+    } = req.query;
+
+    const cat = await entityServer.find("board_category", {
+        name: category,
+        status: "active",
+    });
+    if (!cat.data)
+        return reply.code(404).send(fail("카테고리를 찾을 수 없습니다."));
+
+    const filter: Record<string, unknown> = {
+        category_seq: (cat.data as Record<string, unknown>).seq,
+        status:
+            status === "draft" && req.user?.account_seq ? "draft" : "published",
+    };
+
+    // draft 조회 시 본인 글만
+    if (status === "draft" && req.user?.account_seq) {
+        filter.user_seq = req.user.account_seq;
+    }
+
+    if (pinned !== undefined) filter.pinned = pinned;
+    if (root_seq !== undefined) filter.root_seq = root_seq;
+    if (depth !== undefined) filter.depth = depth;
+
+    const resp = await entityServer.list("board_post", {
+        conditions: filter,
+        search,
+        page,
+        limit: per_page,
+        orderBy: sort,
+        orderDir: order === "asc" ? "ASC" : "DESC",
+    } as Parameters<typeof entityServer.list>[1]);
+
+    return reply.send(ok(resp.data));
+}
+
+// ── 상세 조회 ────────────────────────────────────────────────────────────────
+
+export async function detail(
+    req: FastifyRequest<{ Params: { seq: string } }>,
+    reply: FastifyReply,
+) {
+    const seq = Number(req.params.seq);
+
+    const post = await entityServer.find("board_post", { seq });
+    if (!post.data)
+        return reply.code(404).send(fail("게시글을 찾을 수 없습니다."));
+
+    const item = post.data as Record<string, unknown>;
+    if (item.status === "deleted")
+        return reply.code(404).send(fail("삭제된 게시글입니다."));
+
+    // 카테고리 조회 (view_count_mode 확인)
+    const cat = await entityServer.find("board_category", {
+        seq: item.category_seq,
+    });
+    const catItem = cat.data as Record<string, unknown>;
+
+    // 조회수 처리
+    await incrementViewCount(req, item, catItem);
+
+    // 태그 조회
+    const postTags = await entityServer.list("board_post_tag", {
+        conditions: { post_seq: seq },
+        limit: 50,
+    });
+    const tagSeqs = postTags.data.items.map(
+        (pt: unknown) => (pt as Record<string, unknown>).tag_seq,
+    );
+    const tagNames: string[] = [];
+    for (const tagSeq of tagSeqs) {
+        const tagRes = await entityServer.find("board_tag", { seq: tagSeq });
+        if (tagRes.data)
+            tagNames.push(
+                (tagRes.data as Record<string, unknown>).name as string,
+            );
+    }
+
+    // 파일 목록
+    const fileList = await entityServer.fileList("board_post", {
+        refSeq: seq,
+    });
+
+    const isAnonymous = catItem?.anonymous_enabled === "Y";
+    const responseItem = {
+        ...item,
+        user_seq: isAnonymous ? null : item.user_seq,
+        tags: tagNames,
+        files: fileList.data.items ?? [],
+        is_mine: req.user?.account_seq
+            ? item.user_seq === req.user.account_seq
+            : false,
+    };
+
+    return reply.send(ok(responseItem));
+}
+
+// ── 게시글 작성 ──────────────────────────────────────────────────────────────
+
+export async function create(
+    req: FastifyRequest<{
+        Params: { category: string };
+        Body: {
+            title: string;
+            content: string;
+            parent_seq?: number;
+            pinned?: string;
+            status?: string;
+            tags?: string[];
+        };
+    }>,
+    reply: FastifyReply,
+) {
+    const { category } = req.params;
+    const { title, content, parent_seq, pinned, status, tags } = req.body;
+    const userSeq = req.user!.account_seq as number;
+
+    const cat = await entityServer.find("board_category", {
+        name: category,
+        status: "active",
+    });
+    if (!cat.data)
+        return reply.code(404).send(fail("카테고리를 찾을 수 없습니다."));
+
+    const catItem = cat.data as Record<string, unknown>;
+
+    if (pinned === "Y" && !req.user!.is_admin)
+        return reply.code(403).send(fail("글 고정은 관리자만 가능합니다."));
+
+    // 답글일 때 root_seq, depth 자동 계산
+    let rootSeq: number | undefined;
+    let depth = 0;
+    if (parent_seq) {
+        const parent = await entityServer.find("board_post", {
+            seq: parent_seq,
+        });
+        if (!parent.data)
+            return reply.code(404).send(fail("부모 글을 찾을 수 없습니다."));
+        const p = parent.data as Record<string, unknown>;
+        rootSeq = (p.root_seq as number) ?? (p.seq as number);
+        depth = ((p.depth as number) ?? 0) + 1;
+    }
+
+    const isAnonymous = catItem.anonymous_enabled === "Y";
+    const authorName = isAnonymous ? "익명" : (req.user!.name as string);
+
+    const resp = await entityServer.submit("board_post", {
+        category_seq: catItem.seq,
+        user_seq: userSeq,
+        author_name: authorName,
+        title,
+        content,
+        status: status || "published",
+        parent_seq: parent_seq ?? null,
+        root_seq: rootSeq ?? null,
+        depth,
+        pinned: parent_seq ? "N" : pinned || "N",
+    });
+
+    // 원글이면 root_seq = 자기 seq
+    if (!parent_seq) {
+        await entityServer.submit("board_post", {
+            seq: resp.seq,
+            root_seq: resp.seq,
+        });
+    }
+
+    if (tags && tags.length > 0) {
+        await setPostTags(resp.seq as number, tags);
+    }
+
+    // @username 멘션 파싱
+    await parseMentions("post", resp.seq as number, content);
+
+    return reply.code(201).send(ok({ seq: resp.seq }));
+}
+
+// ── 게시글 수정 ──────────────────────────────────────────────────────────────
+
+export async function update(
+    req: FastifyRequest<{
+        Params: { seq: string };
+        Body: {
+            title?: string;
+            content?: string;
+            status?: string;
+            tags?: string[];
+        };
+    }>,
+    reply: FastifyReply,
+) {
+    const seq = Number(req.params.seq);
+    const { title, content, status, tags } = req.body;
+    const userSeq = req.user!.account_seq as number;
+
+    const post = await entityServer.find("board_post", { seq });
+    if (!post.data)
+        return reply.code(404).send(fail("게시글을 찾을 수 없습니다."));
+
+    const item = post.data as Record<string, unknown>;
+
+    // 비회원 글 수정은 guest-auth 토큰으로 처리
+    if (!item.user_seq) {
+        if (req.user!.guest_post_seq !== seq)
+            return reply.code(403).send(fail("수정 권한이 없습니다."));
+    } else if (item.user_seq !== userSeq && !req.user!.is_admin) {
+        return reply.code(403).send(fail("수정 권한이 없습니다."));
+    }
+
+    await entityServer.submit("board_post", {
+        seq,
+        ...(title !== undefined && { title }),
+        ...(content !== undefined && { content }),
+        ...(status !== undefined && { status }),
+    });
+
+    if (tags !== undefined) {
+        await setPostTags(seq, tags);
+    }
+
+    if (content !== undefined) {
+        await updateMentions("post", seq, content);
+    }
+
+    return reply.send(ok(null));
+}
+
+// ── 게시글 삭제 ──────────────────────────────────────────────────────────────
+
+export async function remove(
+    req: FastifyRequest<{ Params: { seq: string } }>,
+    reply: FastifyReply,
+) {
+    const seq = Number(req.params.seq);
+    const userSeq = req.user!.account_seq as number;
+
+    const post = await entityServer.find("board_post", { seq });
+    if (!post.data)
+        return reply.code(404).send(fail("게시글을 찾을 수 없습니다."));
+
+    const item = post.data as Record<string, unknown>;
+
+    if (!item.user_seq) {
+        if (req.user!.guest_post_seq !== seq)
+            return reply.code(403).send(fail("삭제 권한이 없습니다."));
+    } else if (item.user_seq !== userSeq && !req.user!.is_admin) {
+        return reply.code(403).send(fail("삭제 권한이 없습니다."));
+    }
+
+    // soft delete
+    await entityServer.submit("board_post", { seq, status: "deleted" });
+    return reply.send(ok(null));
+}
+
+// ── 비회원 글작성 ─────────────────────────────────────────────────────────────
+
+export async function guestCreate(
+    req: FastifyRequest<{
+        Params: { category: string };
+        Body: {
+            title: string;
+            content: string;
+            guest_name: string;
+            guest_password: string;
+        };
+    }>,
+    reply: FastifyReply,
+) {
+    const { category } = req.params;
+    const { title, content, guest_name, guest_password } = req.body;
+
+    const cat = await entityServer.find("board_category", {
+        name: category,
+        status: "active",
+    });
+    if (!cat.data)
+        return reply.code(404).send(fail("카테고리를 찾을 수 없습니다."));
+
+    const catItem = cat.data as Record<string, unknown>;
+    if (catItem.guest_write_enabled !== "Y")
+        return reply
+            .code(403)
+            .send(fail("이 게시판은 비회원 글작성이 허용되지 않습니다."));
+
+    const hashed = hashPassword(guest_password);
+
+    const resp = await entityServer.submit("board_post", {
+        category_seq: catItem.seq,
+        user_seq: null,
+        author_name: guest_name,
+        guest_password: hashed,
+        title,
+        content,
+        depth: 0,
+    });
+
+    await entityServer.submit("board_post", {
+        seq: resp.seq,
+        root_seq: resp.seq,
+    });
+
+    return reply.code(201).send(ok({ seq: resp.seq }));
+}
+
+// ── 비회원 본인확인 ───────────────────────────────────────────────────────────
+
+export async function guestAuth(
+    req: FastifyRequest<{
+        Params: { seq: string };
+        Body: { guest_password: string };
+    }>,
+    reply: FastifyReply,
+) {
+    const seq = Number(req.params.seq);
+    const { guest_password } = req.body;
+
+    const post = await entityServer.find("board_post", { seq });
+    if (!post.data)
+        return reply.code(404).send(fail("게시글을 찾을 수 없습니다."));
+
+    const item = post.data as Record<string, unknown>;
+    if (!item.guest_password)
+        return reply.code(400).send(fail("비회원 게시글이 아닙니다."));
+
+    const matched = verifyPassword(
+        guest_password,
+        item.guest_password as string,
+    );
+    if (!matched)
+        return reply.code(401).send(fail("비밀번호가 일치하지 않습니다."));
+
+    const token = jwt.sign({ guest_post_seq: seq }, env.JWT_SECRET, {
+        expiresIn: "30m",
+    });
+    return reply.send(
+        ok({
+            token,
+            note: "이 토큰을 Authorization: Bearer 헤더에 담아 수정/삭제 요청",
+        }),
+    );
+}
+
+// ── 답변 채택 ────────────────────────────────────────────────────────────────
+
+export async function accept(
+    req: FastifyRequest<{ Params: { seq: string } }>,
+    reply: FastifyReply,
+) {
+    const seq = Number(req.params.seq);
+    const userSeq = req.user!.account_seq as number;
+
+    const post = await entityServer.find("board_post", { seq });
+    if (!post.data)
+        return reply.code(404).send(fail("게시글을 찾을 수 없습니다."));
+    const item = post.data as Record<string, unknown>;
+
+    if (item.parent_seq === null)
+        return reply
+            .code(400)
+            .send(fail("원글은 채택할 수 없습니다. 답글만 채택 가능합니다."));
+
+    const rootPost = await entityServer.find("board_post", {
+        seq: item.root_seq,
+    });
+    if (!rootPost.data)
+        return reply.code(404).send(fail("원글을 찾을 수 없습니다."));
+    const rootItem = rootPost.data as Record<string, unknown>;
+    if (rootItem.user_seq !== userSeq && !req.user!.is_admin)
+        return reply.code(403).send(fail("채택 권한이 없습니다."));
+
+    // 기존 채택 해제
+    const prevAccepted = await entityServer.list("board_post", {
+        conditions: { root_seq: item.root_seq, accepted: "Y" },
+        limit: 100,
+    });
+    for (const p of prevAccepted.data.items) {
+        await entityServer.submit("board_post", {
+            seq: (p as Record<string, unknown>).seq,
+            accepted: "N",
+        });
+    }
+
+    await entityServer.submit("board_post", { seq, accepted: "Y" });
+    return reply.send(ok(null));
+}
+
+// ── 읽음 표시 ────────────────────────────────────────────────────────────────
+
+export async function markRead(
+    req: FastifyRequest<{ Params: { seq: string } }>,
+    reply: FastifyReply,
+) {
+    const postSeq = Number(req.params.seq);
+    const userSeq = req.user!.account_seq as number;
+
+    const post = await entityServer.find("board_post", { seq: postSeq });
+    if (!post.data)
+        return reply.code(404).send(fail("게시글을 찾을 수 없습니다."));
+
+    // upsert: unique(post_seq + user_seq) 충돌 시 read_time 갱신
+    await entityServer.submit("board_read_log", {
+        post_seq: postSeq,
+        user_seq: userSeq,
+        read_time: new Date().toISOString(),
+    });
+
+    return reply.send(ok({ read: true }));
+}
+
+// ── 내부 유틸 ────────────────────────────────────────────────────────────────
+
+async function incrementViewCount(
+    req: FastifyRequest,
+    item: Record<string, unknown>,
+    catItem: Record<string, unknown>,
+) {
+    const mode = (catItem?.view_count_mode as string) || "daily";
+    const seq = item.seq as number;
+
+    if (mode === "always") {
+        await entityServer.submit("board_post", {
+            seq,
+            view_count: (item.view_count as number) + 1,
+        });
+        return;
+    }
+
+    // daily / once: Redis key로 중복 방지
+    // key: `view:{seq}:{userOrIp}`
+    const userOrIp =
+        (req.user?.account_seq as string | undefined) ??
+        (req.headers["x-forwarded-for"] as string) ??
+        req.ip;
+    const key = `view:${seq}:${userOrIp}`;
+
+    // Redis 미사용 시 무조건 증가 (fallback)
+    const redis = (req.server as unknown as Record<string, unknown>).redis as
+        | undefined
+        | {
+              get: (k: string) => Promise<string | null>;
+              set: (
+                  k: string,
+                  v: string,
+                  ex?: string,
+                  ttl?: number,
+              ) => Promise<void>;
+          };
+
+    if (!redis) {
+        await entityServer.submit("board_post", {
+            seq,
+            view_count: (item.view_count as number) + 1,
+        });
+        return;
+    }
+
+    const exists = await redis.get(key);
+    if (!exists) {
+        await entityServer.submit("board_post", {
+            seq,
+            view_count: (item.view_count as number) + 1,
+        });
+        if (mode === "daily") {
+            await redis.set(key, "1", "EX", 86400);
+        } else {
+            // once
+            await redis.set(key, "1");
+        }
+    }
+}
+
+async function parseMentions(
+    sourceType: "post" | "comment",
+    sourceSeq: number,
+    content: string,
+) {
+    MENTION_PATTERN.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = MENTION_PATTERN.exec(content)) !== null) {
+        const username = match[1];
+        const user = await entityServer.find("user", { username });
+        if (user.data) {
+            await entityServer.submit("board_mention", {
+                source_type: sourceType,
+                source_seq: sourceSeq,
+                mentioned_user_seq: (user.data as Record<string, unknown>).seq,
+            });
+        }
+    }
+}
+
+async function updateMentions(
+    sourceType: "post" | "comment",
+    sourceSeq: number,
+    newContent: string,
+) {
+    // 현재 멘션 목록 조회
+    const existing = await entityServer.list("board_mention", {
+        conditions: { source_type: sourceType, source_seq: sourceSeq },
+        limit: 100,
+    });
+
+    // 새 본문에서 멘션 파싱
+    MENTION_PATTERN.lastIndex = 0;
+    const newMentions = new Set<number>();
+    let match: RegExpExecArray | null;
+    while ((match = MENTION_PATTERN.exec(newContent)) !== null) {
+        const user = await entityServer.find("user", {
+            username: match[1],
+        });
+        if (user.data)
+            newMentions.add(
+                (user.data as Record<string, unknown>).seq as number,
+            );
+    }
+
+    // 없어진 멘션 삭제
+    for (const m of existing.data.items) {
+        const mData = m as Record<string, unknown>;
+        if (!newMentions.has(mData.mentioned_user_seq as number)) {
+            await entityServer.delete("board_mention", mData.seq as number);
+        } else {
+            newMentions.delete(mData.mentioned_user_seq as number);
+        }
+    }
+
+    // 새로 추가된 멘션 삽입
+    for (const userSeq of newMentions) {
+        await entityServer.submit("board_mention", {
+            source_type: sourceType,
+            source_seq: sourceSeq,
+            mentioned_user_seq: userSeq,
+        });
+    }
+}

package/src/app/routes/board/handlers/ratings.ts

@@ -0,0 +1,60 @@
+import type { FastifyRequest, FastifyReply } from "fastify";
+import { ok, fail, entityServer } from "@gateway/api";
+
+export async function upsert(
+    req: FastifyRequest<{
+        Params: { seq: string };
+        Body: { score: number };
+    }>,
+    reply: FastifyReply,
+) {
+    const targetSeq = Number(req.params.seq);
+    const { score } = req.body;
+    const userSeq = req.user!.account_seq as number;
+
+    if (!Number.isInteger(score) || score < 1 || score > 5)
+        return reply.code(400).send(fail("score는 1~5 정수여야 합니다."));
+
+    // URL 기반 target_type 판별
+    const targetType: "post" | "comment" = (
+        req.routeOptions.url ?? ""
+    ).includes("/comments/")
+        ? "comment"
+        : "post";
+
+    // 대상 존재 확인
+    const entityName = targetType === "post" ? "board_post" : "board_comment";
+    const target = await entityServer.find(entityName, { seq: targetSeq });
+    if (!target.data)
+        return reply
+            .code(404)
+            .send(
+                fail(
+                    `${targetType === "post" ? "게시글" : "댓글"}을 찾을 수 없습니다.`,
+                ),
+            );
+
+    const existing = await entityServer.find("board_rating", {
+        target_type: targetType,
+        target_seq: targetSeq,
+        user_seq: userSeq,
+    });
+
+    if (existing.data) {
+        const existingSeq = (existing.data as Record<string, unknown>)
+            .seq as number;
+        await entityServer.submit("board_rating", {
+            seq: existingSeq,
+            score,
+        });
+        return reply.send(ok({ updated: true }));
+    }
+
+    await entityServer.submit("board_rating", {
+        target_type: targetType,
+        target_seq: targetSeq,
+        user_seq: userSeq,
+        score,
+    });
+    return reply.send(ok({ created: true }));
+}