Add audit log for moderation and admin actions

New audit_log table records actor, action, target and a JSON snapshot
of the details, so entries stay readable after the target is deleted;
the actor is set to NULL when the user is removed. logAudit() is called
from upload delete (single and bulk), comment delete, tag removal, role
create/delete, role permission changes, role assign/revoke and MOTD
updates. Logging failures only warn and never fail the action itself.

The admin page gets an audit card behind the new audit.view permission
with action filter, click-to-filter by user, readable summaries per
action and server-side pagination. Action catalog lives in
shared/utils/audit.ts, labels under admin.auditActions (de/en).

Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

server/api/admin/audit.get.ts

@@ -0,0 +1,50 @@
+import { and, count, desc, eq, type SQL } from 'drizzle-orm'
+import { AUDIT_ACTIONS } from '../../../shared/utils/audit'
+import { auditLog, users } from '../../db/schema'
+
+const PER_PAGE = 25
+
+export default defineEventHandler(async (event) => {
+  await requirePermission(event, 'audit.view')
+  const q = getQuery(event)
+  const page = Math.max(1, Math.floor(Number(q.page)) || 1)
+  const action = String(q.action ?? '')
+  const actorId = Number(q.user)
+
+  const conditions: SQL[] = []
+  if ((AUDIT_ACTIONS as readonly string[]).includes(action)) conditions.push(eq(auditLog.action, action))
+  if (Number.isInteger(actorId) && actorId > 0) conditions.push(eq(auditLog.userId, actorId))
+  const where = conditions.length ? and(...conditions) : undefined
+
+  const db = useDb()
+  const [totalRow, rows] = await Promise.all([
+    db.select({ count: count() }).from(auditLog).where(where),
+    db
+      .select({
+        id: auditLog.id,
+        action: auditLog.action,
+        targetType: auditLog.targetType,
+        targetId: auditLog.targetId,
+        details: auditLog.details,
+        createdAt: auditLog.createdAt,
+        userId: auditLog.userId,
+        userName: users.name,
+        userColor: users.color,
+        userAvatar: users.avatar,
+      })
+      .from(auditLog)
+      .leftJoin(users, eq(auditLog.userId, users.id))
+      .where(where)
+      .orderBy(desc(auditLog.id))
+      .limit(PER_PAGE)
+      .offset((page - 1) * PER_PAGE),
+  ])
+
+  const total = totalRow[0]?.count ?? 0
+  return {
+    items: rows.map(({ userAvatar, ...r }) => ({ ...r, userAvatarUrl: avatarUrl(userAvatar) })),
+    total,
+    perPage: PER_PAGE,
+    pageCount: Math.max(1, Math.ceil(total / PER_PAGE)),
+  }
+})

server/api/admin/motd.put.ts

@@ -6,7 +6,7 @@ const bodySchema = z.object({
 })
 
 export default defineEventHandler(async (event) => {
-  await requirePermission(event, 'site.manage')
+  const actor = await requirePermission(event, 'site.manage')
   const { message } = await readValidatedBody(event, bodySchema.parse)
   const db = useDb()
   await db
@@ -14,5 +14,6 @@ export default defineEventHandler(async (event) => {
     .values({ key: 'motd', value: message })
     .onDuplicateKeyUpdate({ set: { value: message } })
   broadcastToAll({ type: 'motd', message })
+  await logAudit(actor.id, 'update_motd', null, { message })
   return { message }
 })

server/api/admin/roles.post.ts

@@ -5,8 +5,9 @@ const bodySchema = z.object({
 })
 
 export default defineEventHandler(async (event) => {
-  await requirePermission(event, 'roles.manage')
+  const actor = await requirePermission(event, 'roles.manage')
   const { name } = await readValidatedBody(event, bodySchema.parse)
   const id = await ensureRole(name)
+  await logAudit(actor.id, 'create_role', { type: 'role', id }, { name })
   return { id, name }
 })

server/api/admin/roles/[id].delete.ts

@@ -3,7 +3,7 @@ import { roles } from '../../../db/schema'
 import { SYSTEM_ROLES } from '../../../../shared/utils/permissions'
 
 export default defineEventHandler(async (event) => {
-  await requirePermission(event, 'roles.manage')
+  const actor = await requirePermission(event, 'roles.manage')
   const id = Number(getRouterParam(event, 'id'))
   if (!Number.isInteger(id) || id <= 0) {
     throw createError({ statusCode: 400, statusMessage: 'Ungültige ID' })
@@ -17,5 +17,6 @@ export default defineEventHandler(async (event) => {
     throw createError({ statusCode: 400, statusMessage: `Die ${existing[0].name}-Rolle kann nicht gelöscht werden` })
   }
   await db.delete(roles).where(eq(roles.id, id))
+  await logAudit(actor.id, 'delete_role', { type: 'role', id }, { name: existing[0].name })
   return { ok: true }
 })

server/api/admin/roles/[id]/permissions.put.ts

@@ -8,7 +8,7 @@ const bodySchema = z.object({
 })
 
 export default defineEventHandler(async (event) => {
-  await requirePermission(event, 'roles.manage')
+  const actor = await requirePermission(event, 'roles.manage')
   const id = Number(getRouterParam(event, 'id'))
   if (!Number.isInteger(id) || id <= 0) {
     throw createError({ statusCode: 400, statusMessage: 'Ungültige ID' })
@@ -27,6 +27,7 @@ export default defineEventHandler(async (event) => {
     throw createError({ statusCode: 400, statusMessage: 'Die Admin-Rolle hat immer alle Berechtigungen' })
   }
 
+  const previous = await getRolePermissions().then(m => m.get(id) ?? [])
   await db.delete(rolePermissions).where(eq(rolePermissions.roleId, id))
   if (keys.length) {
     const rows = await db.select({ id: permissions.id }).from(permissions).where(inArray(permissions.key, keys))
@@ -34,5 +35,10 @@ export default defineEventHandler(async (event) => {
       await db.insert(rolePermissions).values(rows.map(r => ({ roleId: id, permissionId: r.id })))
     }
   }
+  await logAudit(actor.id, 'update_role_permissions', { type: 'role', id }, {
+    name: role.name,
+    added: keys.filter(k => !previous.includes(k)),
+    removed: previous.filter(k => !keys.includes(k)),
+  })
   return { ok: true }
 })

server/api/admin/users/[id]/roles.post.ts

@@ -7,7 +7,7 @@ const bodySchema = z.object({
 })
 
 export default defineEventHandler(async (event) => {
-  await requirePermission(event, 'users.manage')
+  const actor = await requirePermission(event, 'users.manage')
   const userId = Number(getRouterParam(event, 'id'))
   if (!Number.isInteger(userId) || userId <= 0) {
     throw createError({ statusCode: 400, statusMessage: 'Ungültige ID' })
@@ -15,15 +15,16 @@ export default defineEventHandler(async (event) => {
   const { roleId } = await readValidatedBody(event, bodySchema.parse)
   const db = useDb()
 
-  const [user] = await db.select({ id: users.id }).from(users).where(eq(users.id, userId)).limit(1)
+  const [user] = await db.select({ id: users.id, name: users.name }).from(users).where(eq(users.id, userId)).limit(1)
   if (!user) {
     throw createError({ statusCode: 404, statusMessage: 'Nutzer nicht gefunden' })
   }
-  const [role] = await db.select({ id: roles.id }).from(roles).where(eq(roles.id, roleId)).limit(1)
+  const [role] = await db.select({ id: roles.id, name: roles.name }).from(roles).where(eq(roles.id, roleId)).limit(1)
   if (!role) {
     throw createError({ statusCode: 404, statusMessage: 'Rolle nicht gefunden' })
   }
 
   await assignRole(userId, roleId)
+  await logAudit(actor.id, 'assign_role', { type: 'user', id: userId }, { userName: user.name, role: role.name })
   return { ok: true }
 })

server/api/admin/users/[id]/roles/[roleId].delete.ts

@@ -1,5 +1,5 @@
 import { and, eq } from 'drizzle-orm'
-import { roles, userRoles } from '../../../../../db/schema'
+import { roles, userRoles, users } from '../../../../../db/schema'
 
 export default defineEventHandler(async (event) => {
   const admin = await requirePermission(event, 'users.manage')
@@ -18,6 +18,10 @@ export default defineEventHandler(async (event) => {
     throw createError({ statusCode: 400, statusMessage: 'Du kannst dir nicht selbst die Admin-Rolle entziehen' })
   }
 
-  await db.delete(userRoles).where(and(eq(userRoles.userId, userId), eq(userRoles.roleId, roleId)))
+  const [target] = await db.select({ name: users.name }).from(users).where(eq(users.id, userId)).limit(1)
+  const result = await db.delete(userRoles).where(and(eq(userRoles.userId, userId), eq(userRoles.roleId, roleId)))
+  if (result[0].affectedRows) {
+    await logAudit(admin.id, 'remove_role', { type: 'user', id: userId }, { userName: target?.name ?? null, role: role.name })
+  }
   return { ok: true }
 })

server/api/comments/[id].delete.ts

@@ -1,18 +1,19 @@
 import { unlink } from 'node:fs/promises'
 import { join } from 'node:path'
 import { eq, sql } from 'drizzle-orm'
-import { commentAttachments, comments, uploads } from '../../db/schema'
+import { commentAttachments, comments, uploads, users } from '../../db/schema'
 
 export default defineEventHandler(async (event) => {
-  await requirePermission(event, 'comment.delete')
+  const actor = await requirePermission(event, 'comment.delete')
   const id = Number(getRouterParam(event, 'id'))
   if (!Number.isInteger(id) || id <= 0) {
     throw createError({ statusCode: 400, statusMessage: 'Ungültige ID' })
   }
   const db = useDb()
   const comment = await db
-    .select({ uploadId: comments.uploadId })
+    .select({ uploadId: comments.uploadId, content: comments.content, userId: comments.userId, userName: users.name })
     .from(comments)
+    .innerJoin(users, eq(comments.userId, users.id))
     .where(eq(comments.id, id))
     .limit(1)
     .then(r => r[0])
@@ -30,5 +31,14 @@ export default defineEventHandler(async (event) => {
       await unlink(join(process.cwd(), 'public', f.cover)).catch(() => {})
     }
   }
+  if (comment) {
+    await logAudit(actor.id, 'delete_comment', { type: 'comment', id }, {
+      uploadId: comment.uploadId,
+      authorId: comment.userId,
+      authorName: comment.userName,
+      content: comment.content.slice(0, 500),
+      attachments: files.length,
+    })
+  }
   return { ok: true }
 })

server/api/uploads/[id].delete.ts

@@ -1,10 +1,10 @@
 import { unlink } from 'node:fs/promises'
 import { join } from 'node:path'
 import { eq } from 'drizzle-orm'
-import { commentAttachments, comments, uploads } from '../../db/schema'
+import { commentAttachments, comments, uploads, users } from '../../db/schema'
 
 export default defineEventHandler(async (event) => {
-  await requirePermission(event, 'upload.delete')
+  const actor = await requirePermission(event, 'upload.delete')
   const id = getRouterParam(event, 'id') ?? ''
   if (!/^[A-Za-z0-9]{1,16}$/.test(id)) {
     throw createError({ statusCode: 400, statusMessage: 'Ungültige ID' })
@@ -12,8 +12,9 @@ export default defineEventHandler(async (event) => {
   const db = useDb()
 
   const [upload] = await db
-    .select({ fileName: uploads.fileName, previewImage: uploads.previewImage })
+    .select({ fileName: uploads.fileName, previewImage: uploads.previewImage, type: uploads.type, originalName: uploads.originalName, userId: uploads.userId, userName: users.name })
     .from(uploads)
+    .innerJoin(users, eq(uploads.userId, users.id))
     .where(eq(uploads.id, id))
     .limit(1)
   if (!upload) {
@@ -40,5 +41,11 @@ export default defineEventHandler(async (event) => {
     }
   }
   broadcastToAll({ type: 'upload-deleted', ids: [id] })
+  await logAudit(actor.id, 'delete_upload', { type: 'upload', id }, {
+    uploadType: upload.type,
+    originalName: upload.originalName,
+    uploaderId: upload.userId,
+    uploaderName: upload.userName,
+  })
   return { ok: true }
 })

server/api/uploads/[id]/tags.put.ts

@@ -60,5 +60,8 @@ export default defineEventHandler(async (event) => {
     await db.insert(uploadTags).values(tagRows.map(t => ({ uploadId: id, tagId: t.id })))
   }
 
+  if (removed.length) {
+    await logAudit(user.id, 'remove_tags', { type: 'upload', id }, { removed, isUploader: upload.userId === user.id })
+  }
   return { tags: tagRows.map(t => t.name).sort() }
 })

server/api/uploads/bulk-delete.post.ts

@@ -6,7 +6,7 @@ import { commentAttachments, comments, uploads } from '../../db/schema'
 const ID_RE = /^[A-Za-z0-9]{1,16}$/
 
 export default defineEventHandler(async (event) => {
-  await requirePermission(event, 'upload.delete')
+  const actor = await requirePermission(event, 'upload.delete')
   const body = await readBody<{ ids?: unknown }>(event)
   const raw = Array.isArray(body?.ids) ? body.ids : []
   const ids = [...new Set(raw.filter((x): x is string => typeof x === 'string' && ID_RE.test(x)))].slice(0, 200)
@@ -45,5 +45,6 @@ export default defineEventHandler(async (event) => {
     }
   }
   broadcastToAll({ type: 'upload-deleted', ids: found })
+  await logAudit(actor.id, 'bulk_delete_uploads', null, { ids: found, count: found.length })
   return { ok: true, deleted: found.length }
 })