Create Album endpoint

src/pages/album/[id].astro

@@ -2,6 +2,7 @@
 import prismaClient from 'utils/prisma-client'
 import * as m from 'paraglide/messages'
 import { Image } from 'astro:assets'
+import { AlbumStatus } from '@prisma/client'
 
 import BaseLayout from 'layouts/base.astro'
 import TrackList from 'components/albumPage/TrackList'
@@ -16,10 +17,13 @@ import ouoIcon from 'img/assets/ouo-icon.png'
 
 const { id } = Astro.params
 const { permissions } = Astro.locals
+
 const hasDirect = permissions.includes('SKIP_ADS')
+const hasUpdate = permissions.includes('UPDATE')
+const hiddenCondition = !hasUpdate ? { status: AlbumStatus.SHOW } : {}
 
 const album = await prismaClient.albums.findUnique({
-  where: { id: Number(id) },
+  where: { id: Number(id), ...hiddenCondition },
   include: {
     artists: { select: { artist: true } },
     categories: { select: { categoryName: true } },

src/pages/api/album/create.ts

@@ -0,0 +1,111 @@
+import type { APIRoute } from 'astro'
+import * as s from 'superstruct'
+import { AlbumStatus } from '@prisma/client'
+
+import prismaClient from 'utils/prisma-client'
+import { Status, formToObject, slug } from 'utils/form'
+import { writeImg, getImgColor } from 'utils/img'
+import { handleComplete } from 'integrations/requestCat'
+import { DownloadInput } from 'schemas/album'
+
+const CreateAlbum = s.object({
+  cover: s.instance(File),
+  title: s.optional(s.string()),
+  subTitle: s.optional(s.string()),
+  releaseDate: s.optional(s.date()),
+  label: s.optional(s.string()),
+  vgmdb: s.optional(s.string()),
+  description: s.optional(s.string()),
+  status: s.defaulted(s.enums(Object.values(AlbumStatus)), AlbumStatus.HIDDEN),
+  animations: s.defaulted(s.array(s.integer()), []),
+  artists: s.defaulted(s.array(s.string()), []),
+  categories: s.defaulted(s.array(s.string()), []),
+  classifications: s.defaulted(s.array(s.string()), []),
+  games: s.defaulted(s.array(s.string()), []),
+  platforms: s.defaulted(s.array(s.integer()), []),
+  discs: s.defaulted(s.array(s.object({ number: s.integer(), body: s.string() })), []),
+  downloads: s.defaulted(s.array(DownloadInput), []),
+  related: s.defaulted(s.array(s.number()), []),
+  stores: s.defaulted(s.array(s.object({ provider: s.string(), url: s.string() })), []),
+  request: s.optional(s.integer())
+})
+
+export const POST: APIRoute = async ({ request, locals }) => {
+  const { session, permissions, user } = locals
+
+  if (!session || !user) return Status(401)
+  if (!permissions.includes('CREATE')) return Status(403)
+
+  let body
+  try {
+    const formData = await request.formData()
+    body = s.create(formToObject(formData), CreateAlbum)
+  } catch (err) {
+    return Status(422, (err as Error).message)
+  }
+
+  try {
+    const albumRow = await prismaClient.$transaction(async (tx) => {
+      const artistRows = body.artists.map((name: string) => ({ slug: slug(name), name }))
+
+      const albumRow = await tx.albums.create({
+        data: {
+          title: body.title,
+          subTitle: body.subTitle,
+          releaseDate: body.releaseDate,
+          label: body.label,
+          vgmdb: body.vgmdb,
+          description: body.description,
+          createdBy: user.name,
+          status: body.status,
+          animations: { create: body.animations.map((id) => ({ animation: { connect: { id } } })) },
+          artists: {
+            create: artistRows.map((a) => ({
+              artist: {
+                connectOrCreate: {
+                  create: a,
+                  where: { slug: a.slug }
+                }
+              }
+            }))
+          },
+          categories: { create: body.categories.map((c) => ({ category: { connect: { name: c } } })) },
+          classifications: { create: body.classifications.map((name) => ({ classification: { connect: { name } } })) },
+          games: { create: body.games.map((slug) => ({ game: { connect: { slug } } })) },
+          platforms: { create: body.platforms.map((id) => ({ platform: { connect: { id } } })) },
+          // albumHistories
+          discs: { createMany: { data: body.discs } },
+          relatedAlbums: { create: body.related.map((id) => ({ relatedAlbum: { connect: { id } } })) }
+        },
+        include: { artists: { include: { artist: { select: { name: true } } } } }
+      })
+
+      const handleCover = async () => {
+        const coverPath = await writeImg(body.cover, 'album', albumRow.id)
+        const headerColor = await getImgColor(coverPath)
+        await tx.albums.update({ where: { id: albumRow.id }, data: { headerColor } })
+        albumRow.headerColor = headerColor
+      }
+
+      await Promise.all([
+        handleCover(),
+        tx.downloads.createMany({
+          data: body.downloads.map((d) => ({
+            title: d.title,
+            small: d.small,
+            albumId: albumRow.id,
+            links: { create: d.links }
+          }))
+        })
+      ])
+
+      return albumRow
+    })
+
+    if (albumRow.status === AlbumStatus.SHOW) await handleComplete(albumRow, body.request)
+
+    return Status(200, albumRow.id.toString())
+  } catch (err) {
+    return Status(500, (err as Error).message)
+  }
+}

src/pages/rss.xml.ts

@@ -1,10 +1,11 @@
 import rss, { type RSSFeedItem } from '@astrojs/rss'
+import { AlbumStatus } from '@prisma/client'
 import type { APIContext } from 'astro'
 import prismaClient from 'utils/prisma-client'
 
 export async function GET(context: APIContext) {
   const albums = await prismaClient.albums.findMany({
-    where: { status: 'show' },
+    where: { status: AlbumStatus.SHOW },
     include: { artists: { include: { artist: { select: { name: true } } } } },
     take: 15,
     orderBy: { createdAt: 'desc' }