@meith/web 0.16.0

package/src/server/fixture-post-repo.ts

@@ -0,0 +1,108 @@
+import 'server-only'
+
+import { type ContentScope, PUBLIC_CONTENT } from '@meith/core'
+import type {
+  PostListingRow,
+  PostLocation,
+  PostPage,
+  PostRepository,
+  QuotablePost,
+} from '@meith/posts'
+
+import { SEED_POST_ROWS } from './seed-board'
+
+export class FixturePostRepository implements PostRepository {
+  constructor(private readonly rows: readonly PostListingRow[] = SEED_POST_ROWS) {}
+
+  async findRatingTarget(postId: number) {
+    const row = this.rows.find((entry) => entry.id === postId)
+    return row === undefined
+      ? null
+      : { id: row.id, threadId: row.threadId, authorUserId: row.authorUserId }
+  }
+
+  async findVisibleById(threadId: number, postId: number): Promise<number | null> {
+    return this.rows.some(
+      (row) =>
+        row.threadId === threadId &&
+        row.id === postId &&
+        PUBLIC_CONTENT.states.includes(row.visibility),
+    )
+      ? postId
+      : null
+  }
+
+  async findQuotable(threadId: number, postId: number): Promise<QuotablePost | null> {
+    const row = this.rows.find(
+      (entry) =>
+        entry.threadId === threadId &&
+        entry.id === postId &&
+        PUBLIC_CONTENT.states.includes(entry.visibility),
+    )
+    return row === undefined
+      ? null
+      : { id: row.id, authorUsername: row.authorUsername, message: row.message }
+  }
+
+  async listRevisions(threadId: number, postId: number) {
+    const row = this.rows.find((entry) => entry.threadId === threadId && entry.id === postId)
+    if (row === undefined) return []
+    return [
+      {
+        revision: 0,
+        message: row.message,
+        subject: null,
+        editedByUserId: row.authorUserId,
+        editedByUsername: row.authorUsername,
+        reason: row.editReason,
+        createdAt: row.editedAt ?? row.createdAt,
+        current: true,
+      },
+    ]
+  }
+
+  async locate(
+    threadId: number,
+    postId: number,
+    options: { readonly scope: ContentScope; readonly pageSize: number },
+  ): Promise<PostLocation | null> {
+    const size = Math.max(1, Math.trunc(options.pageSize))
+    const thread = this.rows
+      .filter((row) => row.threadId === threadId && options.scope.states.includes(row.visibility))
+      .sort((a, b) => a.id - b.id)
+
+    const index = thread.findIndex((row) => row.id === postId)
+    if (index === -1) return null
+
+    const page = Math.floor(index / size) + 1
+    return {
+      number: index + 1,
+      page,
+      afterId: page === 1 ? null : (thread[(page - 1) * size - 1]?.id ?? null),
+    }
+  }
+
+  async listThread(
+    threadId: number,
+    options: {
+      readonly afterId?: number
+      readonly limit: number
+      readonly scope: ContentScope
+    },
+  ): Promise<PostPage> {
+    const matches = this.rows
+      .filter(
+        (row) =>
+          row.threadId === threadId &&
+          options.scope.states.includes(row.visibility) &&
+          (options.afterId === undefined || row.id > options.afterId),
+      )
+      .sort((a, b) => a.id - b.id)
+    const page = matches.slice(0, options.limit).map((row) => ({ ...row }))
+    const last = page.at(-1)
+    return {
+      rows: page,
+      nextAfterId: matches.length > options.limit && last ? last.id : null,
+    }
+  }
+}

package/src/server/fixture-thread-repo.ts

@@ -0,0 +1,98 @@
+import 'server-only'
+
+import { authorFilterAdmits, type ContentScope, type ThreadAuthorFilter } from '@meith/core'
+import type {
+  ThreadCursor,
+  ThreadListingRow,
+  ThreadLocation,
+  ThreadPage,
+  ThreadRepository,
+  ThreadSort,
+} from '@meith/threads'
+
+import { SEED_THREAD_ROWS } from './seed-board'
+
+type ThreadOrderKey = Pick<
+  ThreadListingRow,
+  'id' | 'isSticky' | 'lastPostAt' | 'ratingTotal' | 'ratingCount'
+>
+
+function compare(a: ThreadOrderKey, b: ThreadOrderKey, sort: ThreadSort): number {
+  const rating =
+    sort === 'rating'
+      ? b.ratingTotal / (b.ratingCount || 1) - a.ratingTotal / (a.ratingCount || 1) ||
+        b.ratingCount - a.ratingCount
+      : 0
+  return (
+    Number(b.isSticky) - Number(a.isSticky) ||
+    rating ||
+    b.lastPostAt.getTime() - a.lastPostAt.getTime() ||
+    b.id - a.id
+  )
+}
+
+function after(row: ThreadListingRow, cursor: ThreadCursor, sort: ThreadSort): boolean {
+  return compare(row, cursor, sort) > 0
+}
+
+export class FixtureThreadRepository implements ThreadRepository {
+  constructor(private readonly rows: readonly ThreadListingRow[] = SEED_THREAD_ROWS) {}
+
+  async locate(threadId: number): Promise<ThreadLocation | null> {
+    const row = this.rows.find((entry) => entry.id === threadId)
+    return row === undefined ? null : { forumId: row.forumId, authorUserId: row.authorUserId }
+  }
+
+  async findById(
+    id: number,
+    scope: ContentScope,
+    authors: ThreadAuthorFilter,
+  ): Promise<ThreadListingRow | null> {
+    const row = this.rows.find(
+      (entry) =>
+        entry.id === id &&
+        scope.states.includes(entry.visibility) &&
+        authorFilterAdmits(authors, entry.authorUserId),
+    )
+    return row ? { ...row } : null
+  }
+
+  async listForum(
+    forumId: number,
+    options: {
+      readonly after?: ThreadCursor
+      readonly limit: number
+      readonly scope: ContentScope
+      readonly authors: ThreadAuthorFilter
+      readonly sort?: ThreadSort
+    },
+  ): Promise<ThreadPage> {
+    const sort = options.sort ?? 'activity'
+    const matches = this.rows
+      .filter(
+        (row) =>
+          row.forumId === forumId &&
+          options.scope.states.includes(row.visibility) &&
+          authorFilterAdmits(options.authors, row.authorUserId) &&
+          (!options.after || after(row, options.after, sort)),
+      )
+      .sort((a, b) => compare(a, b, sort))
+    const page = matches.slice(0, options.limit).map((row) => ({ ...row }))
+    const last = page.at(-1)
+
+    return {
+      rows: page,
+      nextCursor:
+        matches.length > options.limit && last
+          ? {
+              sort,
+              isSticky: last.isSticky,
+              lastPostAt: last.lastPostAt,
+              ratingTotal: last.ratingTotal,
+              ratingCount: last.ratingCount,
+              id: last.id,
+            }
+          : null,
+    }
+  }
+}

package/src/server/form-state-reporter.ts

@@ -0,0 +1,34 @@
+import { isAppError, logger, publicMessageOf } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+import type { FormState } from './auth-form-state'
+import { getMessageResolver } from './i18n'
+
+export type FormStateReporter = (
+  err: unknown,
+  values?: Record<string, string>,
+) => Promise<FormState>
+
+export function formStateReporter(module: string, message: string): FormStateReporter {
+  return async (err, values) => {
+    if (isAppError(err)) {
+      const error = publicMessageOf(err, await resolver())
+      return values === undefined ? { error } : { error, values }
+    }
+
+    logger({ module }).error({ err }, message)
+
+    const error =
+      (await resolver())?.('notice.app.something-went-wrong-please-try') ??
+      msg('notice.app.something-went-wrong-please-try').text
+    return values === undefined ? { error } : { error, values }
+  }
+}
+
+async function resolver() {
+  try {
+    return await getMessageResolver()
+  } catch {
+    return undefined
+  }
+}

package/src/server/form-values.ts

@@ -0,0 +1,23 @@
+export function text(form: FormData, name: string): string {
+  const value = form.get(name)
+  return typeof value === 'string' ? value : ''
+}
+
+export function trimmedText(form: FormData, name: string): string {
+  return text(form, name).trim()
+}
+
+export function checkbox(form: FormData, name: string): boolean {
+  return form.get(name) !== null
+}
+
+export function positiveIntIn(value: string): number | null {
+  if (!/^[1-9]\d*$/.test(value)) return null
+  const n = Number(value)
+  return Number.isSafeInteger(n) ? n : null
+}
+
+export function positiveInt(form: FormData, name: string): number | null {
+  const value = form.get(name)
+  return typeof value === 'string' ? positiveIntIn(value) : null
+}

package/src/server/forum-admin-actions.ts

@@ -0,0 +1,353 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+
+import { readMatrixCell } from '@meith/authorization'
+import { CacheTags, FORUM_PERMISSION_FIELDS, ValidationError } from '@meith/core'
+import { MODERATOR_RIGHTS } from '@meith/db'
+import { drivers } from '@meith/drivers'
+import {
+  type DropTarget,
+  type ForumOutlineRow,
+  isNudge,
+  isWhereItIs,
+  moveTargetOf,
+  nudgeTarget,
+  outlineOf,
+} from '@meith/forums'
+import { msg } from '@meith/i18n'
+
+import { recordAdminAction, requireAdmin, requireFreshAdmin } from './admin'
+import type { FormState } from './auth-form-state'
+import { getContainer } from './container'
+import { formStateReporter } from './form-state-reporter'
+import { checkbox, trimmedText } from './form-values'
+import { requireForumAdmin } from './forum-admin'
+
+function forumId(form: FormData): number {
+  const id = Number(trimmedText(form, 'forumId'))
+  if (!Number.isSafeInteger(id) || id <= 0) throw new ValidationError(msg('error.app.such-forum'))
+  return id
+}
+
+const toFormState = formStateReporter('forum-admin', 'forum administration write failed')
+
+async function invalidateTree(): Promise<void> {
+  await drivers().cache.invalidateTags([CacheTags.forumTree()])
+  revalidatePath('/admin/forums')
+  revalidatePath('/admin/forums/[id]', 'page')
+}
+
+function refreshForumPermissionScreens(): void {
+  revalidatePath('/admin/forums/[id]', 'page')
+  revalidatePath('/admin/forums/[id]/permissions', 'page')
+}
+
+export async function saveForumOptionsAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+    const id = forumId(form)
+    const repository = requireForumAdmin()
+
+    const title = trimmedText(form, 'title')
+    const slug = trimmedText(form, 'slug')
+    if (title === '') throw new ValidationError(msg('error.app.forum-needs-title'))
+    if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(slug)) {
+      throw new ValidationError(msg('error.app.slug-contain-lower-case-letters-numbers'))
+    }
+
+    const order = Number(trimmedText(form, 'displayOrder'))
+    if (!Number.isSafeInteger(order) || order < 0) {
+      throw new ValidationError(msg('error.app.display-order-must-whole-number'))
+    }
+
+    await repository.updateOptions(id, {
+      title,
+      slug,
+      description: trimmedText(form, 'description') || null,
+      linkUrl: trimmedText(form, 'linkUrl') === '' ? null : trimmedText(form, 'linkUrl'),
+      displayOrder: order,
+      isOpen: checkbox(form, 'isOpen'),
+      allowThreads: checkbox(form, 'allowThreads'),
+      allowReplies: checkbox(form, 'allowReplies'),
+      allowPolls: checkbox(form, 'allowPolls'),
+      allowAttachments: checkbox(form, 'allowAttachments'),
+      requiresPrefix: checkbox(form, 'requiresPrefix'),
+      moderateNewThreads: checkbox(form, 'moderateNewThreads'),
+      moderateNewPosts: checkbox(form, 'moderateNewPosts'),
+    })
+
+    await invalidateTree()
+    await recordAdminAction({ action: 'forum.options_changed', detail: { forumId: id } })
+
+    return { notice: 'saved' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function saveForumPermissionsAction(
+  _prev: FormState,
+  form: FormData,
+): Promise<FormState> {
+  try {
+    await requireAdmin()
+    const id = forumId(form)
+    const groupId = Number(trimmedText(form, 'groupId'))
+    if (!Number.isSafeInteger(groupId) || groupId <= 0) {
+      throw new ValidationError(msg('error.app.such-group'))
+    }
+
+    const values: Record<string, boolean | number | null> = {}
+    for (const field of FORUM_PERMISSION_FIELDS) {
+      const raw = form.get(field.key)
+      values[field.key] = readMatrixCell(field, typeof raw === 'string' ? raw : undefined)
+    }
+
+    await requireForumAdmin().saveOverrides(id, groupId, values)
+
+    refreshForumPermissionScreens()
+    await recordAdminAction({
+      action: 'forum.permissions_changed',
+      detail: { forumId: id, groupId },
+    })
+
+    return { notice: 'saved' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function copyForumPermissionsAction(
+  _prev: FormState,
+  form: FormData,
+): Promise<FormState> {
+  try {
+    await requireFreshAdmin()
+    const id = forumId(form)
+    const repository = requireForumAdmin()
+
+    const descendants = await repository.descendantIds(id)
+    if (descendants.length === 0) {
+      throw new ValidationError(msg('error.app.forum-nothing-beneath'))
+    }
+
+    const groups = (await repository.listGroups()).map((group) => group.id)
+    await repository.copyToDescendants(id, descendants, groups)
+
+    refreshForumPermissionScreens()
+    await recordAdminAction({
+      action: 'forum.permissions_copied',
+      detail: { forumId: id, forums: descendants.length },
+    })
+
+    return { notice: 'copied' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function createForumAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+    const { forums } = getContainer()
+
+    const type = trimmedText(form, 'type')
+    if (type !== 'category' && type !== 'forum' && type !== 'link') {
+      throw new ValidationError(msg('error.app.choose-category-forum-link'))
+    }
+
+    const title = trimmedText(form, 'title')
+    const slug = trimmedText(form, 'slug')
+    if (title === '') throw new ValidationError(msg('error.app.forum-needs-title'))
+    if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(slug)) {
+      throw new ValidationError(msg('error.app.slug-contain-lower-case-letters-numbers'))
+    }
+
+    const parent = trimmedText(form, 'parentId')
+    const parentId = parent === '' ? null : Number(parent)
+    if (parentId !== null && (!Number.isSafeInteger(parentId) || parentId <= 0)) {
+      throw new ValidationError(msg('error.app.such-parent-forum'))
+    }
+
+    await forums.create({
+      type,
+      title,
+      slug,
+      ...(trimmedText(form, 'description') === ''
+        ? {}
+        : { description: trimmedText(form, 'description') }),
+      parentId,
+      ...(trimmedText(form, 'linkUrl') === '' ? {} : { linkUrl: trimmedText(form, 'linkUrl') }),
+    })
+
+    await invalidateTree()
+    await recordAdminAction({ action: 'forum.created', detail: { slug, type } })
+
+    return { notice: 'created' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function moveForumAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireFreshAdmin()
+    const id = forumId(form)
+
+    const parent = trimmedText(form, 'newParentId')
+    const newParentId = parent === '' ? null : Number(parent)
+    if (newParentId !== null && (!Number.isSafeInteger(newParentId) || newParentId <= 0)) {
+      throw new ValidationError(msg('error.app.such-parent-forum'))
+    }
+    if (newParentId === id) {
+      throw new ValidationError(msg('error.app.forum-its-own-parent'))
+    }
+
+    await getContainer().forums.move(id, { newParentId })
+
+    await invalidateTree()
+    refreshForumPermissionScreens()
+    await recordAdminAction({
+      action: 'forum.moved',
+      detail: { forumId: id, newParentId },
+    })
+
+    return { notice: 'moved' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+function dropTarget(form: FormData, outline: readonly ForumOutlineRow[], id: number): DropTarget {
+  const nudge = trimmedText(form, 'nudge')
+
+  if (nudge !== '') {
+    if (!isNudge(nudge)) throw new ValidationError(msg('error.app.direction'))
+
+    const target = nudgeTarget(outline, id, nudge)
+    if (target === null) {
+      throw new ValidationError(msg('error.app.forum-go-any-further-direction'))
+    }
+    return target
+  }
+
+  const parent = trimmedText(form, 'parentId')
+  const after = trimmedText(form, 'afterId')
+  const parentId = parent === '' ? null : Number(parent)
+  const afterId = after === '' ? null : Number(after)
+
+  if (parentId !== null && (!Number.isSafeInteger(parentId) || parentId <= 0)) {
+    throw new ValidationError(msg('error.app.such-parent-forum'))
+  }
+  if (afterId !== null && (!Number.isSafeInteger(afterId) || afterId <= 0)) {
+    throw new ValidationError(msg('error.app.such-forum-follow'))
+  }
+
+  return { parentId, afterId }
+}
+
+export async function arrangeForumAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+    const id = forumId(form)
+
+    const { forums } = getContainer()
+    const outline = outlineOf(await forums.listAll())
+
+    const row = outline.find((entry) => entry.id === id)
+    if (row === undefined) throw new ValidationError(msg('error.app.such-forum'))
+
+    const target = dropTarget(form, outline, id)
+    if (isWhereItIs(outline, id, target)) return { notice: 'unmoved' }
+
+    if (target.parentId !== row.parentId) await requireFreshAdmin()
+
+    await forums.move(id, moveTargetOf(target))
+
+    await invalidateTree()
+    refreshForumPermissionScreens()
+    await recordAdminAction({
+      action: 'forum.moved',
+      detail: { forumId: id, newParentId: target.parentId, afterId: target.afterId },
+    })
+
+    return { notice: 'moved' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function appointModeratorAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+    const id = forumId(form)
+    const repository = requireForumAdmin()
+
+    const username = trimmedText(form, 'username')
+    const groupRaw = trimmedText(form, 'groupId')
+
+    if ((username === '') === (groupRaw === '')) {
+      throw new ValidationError(msg('error.app.name-member-choose-group-both'))
+    }
+
+    let userId: number | null = null
+    let groupId: number | null = null
+
+    if (username !== '') {
+      const member = await repository.findMemberByUsername(username)
+      if (member === null) throw new ValidationError(`No member called “${username}”.`)
+      userId = member.id
+    } else {
+      groupId = Number(groupRaw)
+      if (!Number.isSafeInteger(groupId) || groupId <= 0) {
+        throw new ValidationError(msg('error.app.such-group'))
+      }
+    }
+
+    const rights = Object.fromEntries(
+      MODERATOR_RIGHTS.map((right) => [right, checkbox(form, right)]),
+    ) as Record<(typeof MODERATOR_RIGHTS)[number], boolean>
+
+    await repository.appoint({
+      forumId: id,
+      userId,
+      groupId,
+      cascadeToSubforums: checkbox(form, 'cascadeToSubforums'),
+      rights,
+    })
+
+    refreshForumPermissionScreens()
+    await recordAdminAction({
+      action: 'forum.moderator_appointed',
+      detail: { forumId: id, userId, groupId },
+    })
+
+    return { notice: 'saved' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function removeModeratorAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+    const id = forumId(form)
+    const appointmentId = Number(trimmedText(form, 'appointmentId'))
+    if (!Number.isSafeInteger(appointmentId) || appointmentId <= 0) {
+      throw new ValidationError(msg('error.app.such-appointment'))
+    }
+
+    await requireForumAdmin().removeModerator(id, appointmentId)
+
+    refreshForumPermissionScreens()
+    await recordAdminAction({
+      action: 'forum.moderator_removed',
+      detail: { forumId: id, appointmentId },
+    })
+
+    return { notice: 'removed' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}