@meith/web 0.16.0

package/src/server/modcp.ts

@@ -0,0 +1,125 @@
+import 'server-only'
+
+import { cache } from 'react'
+
+import type { Actor, ModeratedTarget, ModeratorRights } from '@meith/authorization'
+import { canHoldThreads } from '@meith/forums'
+import type { Translator } from '@meith/i18n'
+import { ModerationQueue } from '@meith/moderation'
+
+import { untranslated } from '@/view/time'
+
+import { getContainer } from './container'
+import { getActor } from './context'
+import { hasReportScope, resolveReportScope } from './report-scope'
+
+export interface ModCpAccess {
+  readonly actor: Actor
+  readonly userId: number
+  readonly forumIds: readonly number[]
+  readonly hasGroupAccess: boolean
+  readonly canWarn: boolean
+  readonly canLookUpIp: boolean
+}
+
+export const resolveModCpAccess = cache(
+  async function resolveModCpAccess(): Promise<ModCpAccess | null> {
+    const actor = await getActor()
+    const { authorizer, modcp } = getContainer()
+
+    if (modcp === null || actor.userId === null) return null
+
+    const hasGroupAccess = authorizer.can(actor, 'modcp.access')
+    const forumIds = await authorizer.moderatedForumIds(actor)
+    if (!hasGroupAccess && forumIds.length === 0) return null
+
+    return {
+      actor,
+      userId: actor.userId,
+      forumIds,
+      hasGroupAccess,
+      canWarn: getContainer().warnings !== null && authorizer.can(actor, 'user.warn'),
+      canLookUpIp: actor.global.isAdministrator === true || actor.global.isSuperModerator === true,
+    }
+  },
+)
+
+export interface ModCpCounts {
+  readonly pending: number
+  readonly openReports: number
+}
+
+export const modCpCounts = cache(async function modCpCounts(): Promise<ModCpCounts> {
+  const access = await resolveModCpAccess()
+  if (access === null) return { pending: 0, openReports: 0 }
+
+  const { moderationQueue, reports } = getContainer()
+
+  const [pending, openReports] = await Promise.all([
+    moderationQueue === null
+      ? Promise.resolve(0)
+      : new ModerationQueue({ queue: moderationQueue })
+          .countPending(access.forumIds)
+          .catch(() => 0),
+    reports === null
+      ? Promise.resolve(0)
+      : resolveReportScope()
+          .then((scope) => (hasReportScope(scope) ? reports.countOpen(scope) : 0))
+          .catch(() => 0),
+  ])
+
+  return { pending, openReports }
+})
+
+export interface ModeratedForumRights {
+  readonly forumId: number
+  readonly title: string
+  readonly slug: string
+  readonly rights: readonly string[]
+}
+
+const RIGHT_LABEL_KEYS: Readonly<Record<keyof ModeratorRights, string>> = {
+  canApproveContent: 'modcp.right.approve-content',
+  canEditPosts: 'modcp.right.edit-posts',
+  canSoftDeletePosts: 'modcp.right.delete-posts',
+  canRestorePosts: 'modcp.right.restore-posts',
+  canOpenCloseThreads: 'modcp.right.lock-unlock',
+  canStickThreads: 'modcp.right.pin-unpin',
+  canMoveThreads: 'modcp.right.move-threads',
+  canMergeThreads: 'modcp.right.merge-threads',
+  canSplitThreads: 'modcp.right.split-threads',
+}
+
+export async function moderatedForumRights(
+  access: ModCpAccess,
+  t: Translator = untranslated(),
+): Promise<readonly ModeratedForumRights[]> {
+  const { authorizer, forums } = getContainer()
+  const rows = await forums.listListing()
+
+  const resolved = await Promise.all(
+    access.forumIds.map(async (forumId): Promise<ModeratedForumRights | null> => {
+      const row = rows.find((r) => r.id === forumId)
+      if (row === undefined || !canHoldThreads(row.type)) return null
+      const rights = await authorizer.moderatorRightsIn(access.actor, forumId)
+      return {
+        forumId,
+        title: row.title,
+        slug: row.slug,
+        rights: (Object.keys(RIGHT_LABEL_KEYS) as (keyof ModeratorRights)[])
+          .filter((key) => rights[key])
+          .map((key) => t.t(RIGHT_LABEL_KEYS[key])),
+      }
+    }),
+  )
+
+  return resolved.filter((row): row is ModeratedForumRights => row !== null)
+}
+
+export async function moderatorTargetFor(
+  actor: Actor,
+  forumId: number,
+  forum: Awaited<ReturnType<ReturnType<typeof getContainer>['authorizer']['forumMatrix']>>,
+): Promise<ModeratedTarget> {
+  return getContainer().authorizer.moderatorTargetIn(actor, forumId, forum)
+}

package/src/server/moderation-actions.ts

@@ -0,0 +1,165 @@
+'use server'
+
+import { redirect } from 'next/navigation'
+
+import { ForbiddenError, ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+import { ModerationQueue, parseSelection } from '@meith/moderation'
+
+import { recordAdminAction } from './admin'
+import type { FormState } from './auth-form-state'
+import { avatarService } from './avatars'
+import { getContainer } from './container'
+import { getActor } from './context'
+import { formStateReporter } from './form-state-reporter'
+import { tr } from './i18n'
+import { emitEvent } from './plugin-view'
+
+const toFormState = formStateReporter('moderation-actions', 'unexpected error in the queue')
+
+function outcomeQuery(outcome: {
+  decision: string
+  applied: number
+  refused: number
+  missing: number
+}): string {
+  const parts = [`did=${outcome.decision}`, `n=${outcome.applied}`]
+  if (outcome.refused > 0) parts.push(`refused=${outcome.refused}`)
+  if (outcome.missing > 0) parts.push(`gone=${outcome.missing}`)
+  return parts.join('&')
+}
+
+export async function moderateQueueAction(_prev: FormState, form: FormData): Promise<FormState> {
+  const decision = form.get('decision')
+  if (decision !== 'approve' && decision !== 'reject') {
+    return { error: await tr('notice.app.choose-approve-reject') }
+  }
+
+  const { authorizer, moderationQueue } = getContainer()
+  if (moderationQueue === null) {
+    return {
+      error: await tr('notice.app.board-running-in-memory-sample-data-2'),
+    }
+  }
+
+  let outcome: Awaited<ReturnType<ModerationQueue['decide']>>
+  try {
+    const actor = await getActor()
+    if (actor.userId === null) {
+      throw new ForbiddenError(msg('error.app.must-logged-moderate'))
+    }
+
+    const moderated = new Set(await authorizer.moderatedForumIds(actor))
+    if (moderated.size === 0) {
+      throw new ForbiddenError(msg('error.app.moderate-any-forums'))
+    }
+
+    const selection = parseSelection(
+      form.getAll('item').filter((v): v is string => typeof v === 'string'),
+    )
+    if (selection.length === 0) {
+      throw new ValidationError(msg('error.app.select-at-least-one-item'))
+    }
+
+    outcome = await new ModerationQueue({ queue: moderationQueue }).decide({
+      selection,
+      decision,
+      moderatedForumIds: moderated,
+      actorUserId: actor.userId,
+    })
+
+    const moderation = { moderatorId: actor.userId, reason: null }
+    for (const item of outcome.decided) {
+      await emitEvent(
+        'approval.decided',
+        { kind: item.kind, id: item.id, approved: decision === 'approve' },
+        moderation,
+      )
+    }
+    if (outcome.decided.length > 0) {
+      await emitEvent(
+        'moderation.logged',
+        { action: `queue.${decision}`, targetId: outcome.decided[0]!.id },
+        moderation,
+      )
+    }
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect(`/moderation?${outcomeQuery(outcome)}`)
+}
+
+export async function setSignatureLockAction(_prev: FormState, form: FormData): Promise<FormState> {
+  const text = (name: string): string => {
+    const value = form.get(name)
+    return typeof value === 'string' ? value.trim() : ''
+  }
+
+  const userId = Number(text('userId'))
+  const returnTo = userId > 0 ? `/member/${userId}` : '/'
+
+  try {
+    const actor = await getActor()
+    if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+    getContainer().authorizer.require(actor, 'user.warn')
+
+    const store = getContainer().signatures
+    if (store === null) {
+      throw new ForbiddenError(msg('error.app.board-keeps-signatures'))
+    }
+    if (!Number.isInteger(userId) || userId <= 0) {
+      throw new ValidationError(msg('error.app.such-member'))
+    }
+
+    const locked = form.get('locked') === '1'
+    const reason = text('reason')
+
+    if (locked && reason === '') {
+      throw new ValidationError(msg('error.app.say-why-member-shown-reason'))
+    }
+
+    await store.setLocked({ userId, locked, reason: locked ? reason : null })
+    await recordAdminAction({
+      action: locked ? 'signature.lock' : 'signature.unlock',
+      detail: { userId },
+    })
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect(`${returnTo}?signature=${form.get('locked') === '1' ? 'locked' : 'unlocked'}`)
+}
+
+export async function setAvatarLockAction(_prev: FormState, form: FormData): Promise<FormState> {
+  const text = (name: string): string => {
+    const value = form.get(name)
+    return typeof value === 'string' ? value.trim() : ''
+  }
+
+  const userId = Number(text('userId'))
+  const returnTo = userId > 0 ? `/member/${userId}` : '/'
+
+  try {
+    const actor = await getActor()
+    if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+    getContainer().authorizer.require(actor, 'user.warn')
+
+    const service = avatarService()
+    if (service === null) throw new ForbiddenError(msg('error.app.board-keeps-avatars'))
+    if (!Number.isInteger(userId) || userId <= 0) {
+      throw new ValidationError(msg('error.app.such-member'))
+    }
+
+    const locked = form.get('locked') === '1'
+    await service.setLock({ userId, locked, reason: text('reason') })
+    await recordAdminAction({
+      action: locked ? 'avatar.lock' : 'avatar.unlock',
+      detail: { userId },
+    })
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect(`${returnTo}?avatar=${form.get('locked') === '1' ? 'locked' : 'unlocked'}`)
+}

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

@@ -0,0 +1,217 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+
+import { CacheTags, ValidationError } from '@meith/core'
+import type {
+  NavigationAudience,
+  NavigationDropTarget,
+  NavigationItemInput,
+  PostgresNavigationRepository,
+} from '@meith/db'
+import { drivers } from '@meith/drivers'
+import { msg } from '@meith/i18n'
+
+import { NAVIGATION_AUDIENCE_VALUES, outlineOf } from '../view/navigation'
+import { isNavigationNudge, isWhereItIs, nudgeTarget } from '../view/navigation-arrange'
+import { recordAdminAction, requireAdmin } from './admin'
+import type { FormState } from './auth-form-state'
+import { formStateReporter } from './form-state-reporter'
+import { checkbox, trimmedText } from './form-values'
+import { navigationRepository } from './navigation'
+import { isSafeLocalPath } from './safe-path'
+
+const PANEL = '/admin/content/navigation'
+
+const toFormState = formStateReporter('navigation-admin', 'navigation administration write failed')
+
+function requireNavigation(): PostgresNavigationRepository {
+  const repository = navigationRepository()
+  if (repository === null) {
+    throw new ValidationError(msg('error.app.board-running-in-memory-navigation'))
+  }
+  return repository
+}
+
+function itemId(form: FormData): number {
+  const value = Number(trimmedText(form, 'id'))
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new ValidationError(msg('error.app.such-row'))
+  }
+  return value
+}
+
+function isAbsoluteWebAddress(value: string): boolean {
+  try {
+    const url = new URL(value)
+    return url.protocol === 'http:' || url.protocol === 'https:'
+  } catch {
+    return false
+  }
+}
+
+function href(form: FormData): string {
+  const value = trimmedText(form, 'href')
+  if (value === '') throw new ValidationError(msg('error.db.navigation-item-needs-address'))
+  if (isSafeLocalPath(value) || isAbsoluteWebAddress(value)) return value
+  throw new ValidationError(msg('error.app.navigation-address-path-or-web-address'))
+}
+
+function audience(form: FormData): NavigationAudience {
+  const value = trimmedText(form, 'audience')
+  const found = NAVIGATION_AUDIENCE_VALUES.find((entry) => entry === value)
+  if (found === undefined) throw new ValidationError(msg('error.app.navigation-audience-unknown'))
+  return found
+}
+
+function optionalId(form: FormData, name: string): number | null {
+  const value = trimmedText(form, name)
+  if (value === '') return null
+
+  const parsed = Number(value)
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+    throw new ValidationError(msg('error.app.such-row'))
+  }
+  return parsed
+}
+
+function visibleToGroups(form: FormData): readonly number[] {
+  return form
+    .getAll('groups')
+    .map((value) => Number(typeof value === 'string' ? value : ''))
+    .filter((id) => Number.isSafeInteger(id) && id > 0)
+}
+
+function itemInput(form: FormData): NavigationItemInput {
+  return {
+    parentId: optionalId(form, 'parentId'),
+    label: trimmedText(form, 'label'),
+    href: href(form),
+    audience: audience(form),
+    newTab: checkbox(form, 'newTab'),
+    enabled: checkbox(form, 'enabled'),
+    visibleToGroups: visibleToGroups(form),
+  }
+}
+
+async function refresh(): Promise<void> {
+  await drivers().cache.invalidateTags([CacheTags.navigation()])
+  revalidatePath(PANEL)
+}
+
+export async function createNavigationItemAction(
+  _prev: FormState,
+  form: FormData,
+): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const navigationItemId = await requireNavigation().create(itemInput(form))
+
+    await refresh()
+    await recordAdminAction({
+      action: 'content.navigation_item_added',
+      detail: { navigationItemId },
+    })
+
+    return { notice: 'saved' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function updateNavigationItemAction(
+  _prev: FormState,
+  form: FormData,
+): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const navigationItemId = itemId(form)
+    await requireNavigation().update(navigationItemId, itemInput(form))
+
+    await refresh()
+    await recordAdminAction({
+      action: 'content.navigation_item_changed',
+      detail: { navigationItemId },
+    })
+
+    return { notice: 'saved' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function deleteNavigationItemAction(
+  _prev: FormState,
+  form: FormData,
+): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const navigationItemId = itemId(form)
+    await requireNavigation().delete(navigationItemId)
+
+    await refresh()
+    await recordAdminAction({
+      action: 'content.navigation_item_removed',
+      detail: { navigationItemId },
+    })
+
+    return { notice: 'deleted' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function arrangeNavigationItemAction(
+  _prev: FormState,
+  form: FormData,
+): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const repository = requireNavigation()
+    const navigationItemId = itemId(form)
+    const outline = outlineOf(await repository.list())
+
+    if (!outline.some((row) => row.id === navigationItemId)) {
+      throw new ValidationError(msg('error.app.such-row'))
+    }
+
+    const target = dropTarget(form, outline, navigationItemId)
+    if (isWhereItIs(outline, navigationItemId, target)) return { notice: 'unmoved' }
+
+    await repository.arrange(navigationItemId, target)
+
+    await refresh()
+    await recordAdminAction({
+      action: 'content.navigation_item_moved',
+      detail: { navigationItemId, parentId: target.parentId, afterId: target.afterId },
+    })
+
+    return { notice: 'moved' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+function dropTarget(
+  form: FormData,
+  outline: ReturnType<typeof outlineOf>,
+  id: number,
+): NavigationDropTarget {
+  const nudge = trimmedText(form, 'nudge')
+
+  if (nudge !== '') {
+    if (!isNavigationNudge(nudge)) throw new ValidationError(msg('error.app.direction'))
+
+    const target = nudgeTarget(outline, id, nudge)
+    if (target === null) {
+      throw new ValidationError(msg('error.app.navigation-item-go-further-direction'))
+    }
+    return target
+  }
+
+  return { parentId: optionalId(form, 'parentId'), afterId: optionalId(form, 'afterId') }
+}

package/src/server/navigation.ts

@@ -0,0 +1,112 @@
+import 'server-only'
+
+import type { Actor } from '@meith/authorization'
+import { CacheTags, cachedGlobal, env, logger } from '@meith/core'
+import { getDb, type NavigationItemRow, PostgresNavigationRepository } from '@meith/db'
+import { drivers } from '@meith/drivers'
+import { pluginKeyOfNavigation, pluginNavigationPlacements } from '@meith/plugin-kit'
+import type { LinkModel, ViewerModel } from '@meith/theme-kit'
+
+import { buildNavigation, defaultNavigationItems, type NavigationNames } from '../view/navigation'
+import { getContainer } from './container'
+import { getTranslator } from './i18n'
+import { activeDefinitions, pluginHost, syncPluginEnablement } from './plugin-host'
+import { searchEnabled } from './search'
+
+const TTL_SECONDS = 60
+
+export function navigationRepository(): PostgresNavigationRepository | null {
+  return env.DATA_SOURCE === 'postgres' ? new PostgresNavigationRepository(getDb()) : null
+}
+
+export async function navigationItems(): Promise<readonly NavigationItemRow[]> {
+  const repository = navigationRepository()
+  if (repository === null) return defaultNavigationItems()
+
+  try {
+    return await cachedGlobal<NavigationItemRow[]>(
+      drivers().cache,
+      { key: ['navigation', 'items'], tags: [CacheTags.navigation()], revalidate: TTL_SECONDS },
+      async () => [...(await repository.list())],
+    )
+  } catch (error) {
+    logger().warn({ err: String(error) }, 'could not read the board navigation')
+    return defaultNavigationItems()
+  }
+}
+
+export function pluginNavigationNames(): NavigationNames {
+  return Object.fromEntries(
+    pluginNavigationPlacements(activeDefinitions()).map((item) => [
+      item.key,
+      { label: item.label, labelKey: item.labelKey, labelArgs: item.labelArgs },
+    ]),
+  )
+}
+
+/**
+ * A row belongs to a plugin that is switched off, or has failed its way off, or
+ * is no longer in the build. It is left in place — an operator's ordering is
+ * worth keeping — but it is not a link anybody should be offered.
+ */
+async function pluginRowIsLive(key: string | null): Promise<boolean> {
+  const pluginKey = pluginKeyOfNavigation(key)
+  if (pluginKey === null) return true
+
+  await syncPluginEnablement()
+  return activeDefinitions().some((plugin) => plugin.key === pluginKey)
+    ? pluginHost.isEnabled(pluginKey)
+    : false
+}
+
+function pluginNavigationDrifted(items: readonly NavigationItemRow[]): boolean {
+  const declared = pluginNavigationPlacements(activeDefinitions())
+  const stored = new Map(
+    items
+      .filter((item) => item.key?.startsWith('plugin.') === true)
+      .map((item) => [item.key as string, item.href] as const),
+  )
+  if (declared.length !== stored.size) return true
+  return declared.some((item) => stored.get(item.key) !== item.href)
+}
+
+export async function boardNavigation(
+  actor: Actor,
+  viewer: ViewerModel,
+): Promise<readonly LinkModel[]> {
+  const { authorizer } = getContainer()
+
+  let items = await navigationItems()
+  if (pluginNavigationDrifted(items)) {
+    await syncPluginNavigation()
+    items = await navigationItems()
+  }
+  const live = await Promise.all(items.map((item) => pluginRowIsLive(item.key)))
+  const shown = items.filter((_, index) => live[index] === true)
+
+  return buildNavigation(shown, viewer, {
+    searchEnabled: await searchEnabled(),
+    t: await getTranslator(),
+    names: pluginNavigationNames(),
+    admits: (item) => authorizer.inAnyGroup(actor, item.visibleToGroups),
+  })
+}
+
+export async function syncPluginNavigation(): Promise<void> {
+  const repository = navigationRepository()
+  if (repository === null) return
+
+  try {
+    await repository.syncPluginItems(
+      pluginNavigationPlacements(activeDefinitions()).map((item) => ({
+        key: item.key,
+        href: item.href,
+        audience: item.audience,
+        parentKey: item.parentKey,
+      })),
+    )
+    await drivers().cache.invalidateTags([CacheTags.navigation()])
+  } catch (error) {
+    logger().warn({ err: String(error) }, 'could not reconcile the plugin navigation')
+  }
+}

package/src/server/nonce.ts

@@ -0,0 +1,13 @@
+import 'server-only'
+
+import { headers } from 'next/headers'
+
+import { NONCE_HEADER } from './location-header'
+
+export async function cspNonce(): Promise<string | undefined> {
+  try {
+    return (await headers()).get(NONCE_HEADER) ?? undefined
+  } catch {
+    return undefined
+  }
+}