homaroma/apps/backend/src/routes/articles.js

import { Elysia, t } from "elysia";
import prisma from "../lib/prisma";
export const articlesRoute = new Elysia({ prefix: "/articles" })
    .get("/", async ({ query, set }) => {
    try {
        const { publishedOnly } = query;
        const where = publishedOnly === 'true' ? { isPublished: true } : {};
        return await prisma.article.findMany({
            where,
            orderBy: { createdAt: 'desc' }
        });
    }
    catch (err) {
        set.status = 500;
        return { error: "Failed to load articles" };
    }
})
    .get("/:slug", async ({ params: { slug }, set }) => {
    try {
        const article = await prisma.article.findUnique({
            where: { slug }
        });
        if (!article) {
            set.status = 404;
            return { error: "Article not found" };
        }
        return article;
    }
    catch (err) {
        set.status = 500;
        return { error: "Failed to fetch article" };
    }
})
    .get("/id/:id", async ({ params: { id }, set }) => {
    try {
        const article = await prisma.article.findUnique({
            where: { id: parseInt(id, 10) }
        });
        if (!article) {
            set.status = 404;
            return { error: "Article not found" };
        }
        return article;
    }
    catch (err) {
        set.status = 500;
        return { error: "Failed to fetch article" };
    }
})
    .post("/", async ({ body, set }) => {
    try {
        const data = body;
        return await prisma.article.create({
            data: {
                title: data.title,
                slug: data.slug,
                coverImage: data.coverImage,
                content: data.content,
                isPublished: data.isPublished
            }
        });
    }
    catch (err) {
        console.error(err);
        set.status = 500;
        return { error: "Failed to create article. Ensure slug is unique." };
    }
}, {
    body: t.Object({
        title: t.String(),
        slug: t.String(),
        coverImage: t.Optional(t.String()),
        content: t.String(),
        isPublished: t.Boolean()
    })
})
    .put("/:id", async ({ params: { id }, body, set }) => {
    try {
        const data = body;
        return await prisma.article.update({
            where: { id: parseInt(id, 10) },
            data: {
                title: data.title,
                slug: data.slug,
                coverImage: data.coverImage,
                content: data.content,
                isPublished: data.isPublished
            }
        });
    }
    catch (err) {
        set.status = 500;
        return { error: "Failed to update article" };
    }
}, {
    body: t.Object({
        title: t.String(),
        slug: t.String(),
        coverImage: t.Optional(t.String()),
        content: t.String(),
        isPublished: t.Boolean()
    })
})
    .delete("/:id", async ({ params: { id }, set }) => {
    try {
        await prisma.article.delete({
            where: { id: parseInt(id, 10) }
        });
        return { success: true };
    }
    catch (err) {
        set.status = 500;
        return { error: "Failed to delete article" };
    }
})
    .patch("/:id/translations", async ({ params, body, set }) => {
    const id = Number(params.id);
    if (isNaN(id)) {
        set.status = 400;
        return { error: "Invalid article ID" };
    }
    const payload = body;
    const results = [];
    const LANGS = ['th', 'en', 'ja', 'zh', 'vi', 'ko'];
    for (const lang of LANGS) {
        const title = typeof payload.title === 'string' ? (lang === 'th' ? payload.title : null) : payload.title?.[lang];
        const content = typeof payload.content === 'string' ? (lang === 'th' ? payload.content : null) : payload.content?.[lang];
        if (!title && !content)
            continue;
        const existing = await prisma.articleTranslation.findUnique({
            where: { articleId_langCode: { articleId: id, langCode: lang } }
        });
        const updateData = {};
        if (title)
            updateData.title = title;
        if (content)
            updateData.content = content;
        if (existing) {
            const updated = await prisma.articleTranslation.update({
                where: { id: existing.id },
                data: updateData
            });
            results.push(updated);
        }
        else {
            const created = await prisma.articleTranslation.create({
                data: { articleId: id, langCode: lang, ...updateData }
            });
            results.push(created);
        }
    }
    const updated = await prisma.article.findUnique({
        where: { id },
        include: { translations: true }
    });
    return { success: true, translations: results, article: updated };
});
//# sourceMappingURL=articles.js.map