90 lines
3.6 KiB
TypeScript
90 lines
3.6 KiB
TypeScript
import { NextRequest, NextResponse } from 'next/server'
|
|
import { getPayload } from 'payload'
|
|
import configPromise from '@payload-config'
|
|
import type { Media } from '@payload-types'
|
|
import { resolveCoverImage } from '@/lib/agent-media'
|
|
import { resolveAttachments, deleteFileDocs } from '@/lib/agent-files'
|
|
|
|
export const dynamic = 'force-dynamic'
|
|
|
|
/** Agent update endpoint: PUT /api/agent/posts/:slug */
|
|
export async function PUT(req: NextRequest, ctx: { params: Promise<{ slug: string }> }) {
|
|
const key = process.env.AGENT_API_KEY
|
|
if (!key || req.headers.get('x-agent-key') !== key) {
|
|
return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
|
|
}
|
|
|
|
const payload = await getPayload({ config: configPromise })
|
|
const { slug } = await ctx.params
|
|
const body = (await req.json().catch(() => null)) as Record<string, unknown> | null
|
|
if (!body) return NextResponse.json({ error: 'invalid JSON body' }, { status: 400 })
|
|
|
|
const existing = await payload.find({
|
|
collection: 'posts',
|
|
where: { slug: { equals: slug } },
|
|
limit: 1,
|
|
})
|
|
const post = existing.docs[0]
|
|
if (!post) return NextResponse.json({ error: 'not found' }, { status: 404 })
|
|
|
|
// Only writable fields; status is admin-only (except the explicit publish flag)
|
|
const allowed = ['title', 'slug', 'dek', 'teaser', 'content', 'category', 'access', 'readingMinutes', 'cover'] as const
|
|
const data: Record<string, unknown> = {}
|
|
for (const field of allowed) {
|
|
if (field in body) data[field] = body[field]
|
|
}
|
|
|
|
// Explicit image payload (inline base64 or remote URL) → stored as a media document.
|
|
let coverUrl: string | null = null
|
|
if ('coverImage' in body && body.coverImage != null) {
|
|
try {
|
|
const cover = await resolveCoverImage(payload, body.coverImage)
|
|
data.cover = cover.id
|
|
coverUrl = cover.url
|
|
} catch (err) {
|
|
return NextResponse.json({ error: (err as Error).message }, { status: 400 })
|
|
}
|
|
}
|
|
|
|
// Per-post work files (inline base64) → stored as gated `files` documents.
|
|
// Like coverImage, `attachments` is an input transform, not a raw field.
|
|
// Sending it REPLACES the post's file set; omit it to keep existing files.
|
|
let attachments: Awaited<ReturnType<typeof resolveAttachments>> = []
|
|
if ('attachments' in body && body.attachments != null) {
|
|
try {
|
|
attachments = await resolveAttachments(payload, body.attachments)
|
|
data.attachments = attachments.map(a => a.id)
|
|
} catch (err) {
|
|
return NextResponse.json({ error: (err as Error).message }, { status: 400 })
|
|
}
|
|
}
|
|
|
|
// `publish` is an explicit opt-in flag; unpublishing stays admin-only.
|
|
if (body.publish === true) {
|
|
data.status = 'published'
|
|
if (!post.publishedAt) data.publishedAt = new Date().toISOString()
|
|
}
|
|
|
|
let doc
|
|
try {
|
|
doc = await payload.update({ collection: 'posts', id: post.id, data, depth: 0 })
|
|
} catch (err) {
|
|
// The post write failed — don't orphan the file docs created above
|
|
// (the post keeps its previous attachments, which are untouched).
|
|
if (attachments.length) await deleteFileDocs(payload, attachments.map(a => a.id))
|
|
return NextResponse.json({ error: (err as Error).message }, { status: 400 })
|
|
}
|
|
|
|
if (!coverUrl && typeof data.cover === 'number') {
|
|
const coverDoc: Media = await payload.findByID({ collection: 'media', id: data.cover })
|
|
coverUrl = coverDoc.url ?? null
|
|
}
|
|
|
|
return NextResponse.json({
|
|
id: doc.id, title: doc.title, slug: doc.slug,
|
|
status: doc.status, access: doc.access, category: doc.category,
|
|
cover: { id: data.cover ?? post.cover, url: coverUrl },
|
|
attachments: attachments.map(a => ({ id: a.id, filename: a.filename, access: a.access, url: `/api/files/${a.id}` })),
|
|
})
|
|
}
|