@meith/web 0.16.0

package/src/server/plugin-pages.ts

@@ -0,0 +1,192 @@
+import 'server-only'
+
+import forumConfig from '@board/config'
+import type { ReactNode } from 'react'
+
+import { env, logger, readPluginEnv } from '@meith/core'
+import { getDb, pluginData, pluginGrants, pluginUsers } from '@meith/db'
+import {
+  type PluginData,
+  type PluginDefinition,
+  type PluginGrants,
+  type PluginNotify,
+  type PluginRuntimeContext,
+  type PluginUsers,
+  pluginNotify,
+  resolvePluginSettings,
+  unavailablePluginData,
+  unavailablePluginGrants,
+  unavailablePluginNotify,
+  unavailablePluginUsers,
+} from '@meith/plugin-kit'
+
+import { getTranslator } from './i18n'
+import { notificationService } from './notifications'
+import { getSettingOverrides } from './settings'
+
+const REQUEST_STATEMENT_TIMEOUT_MS = 3_000
+
+export function grantsFor(pluginKey: string): PluginGrants {
+  return env.DATA_SOURCE === 'postgres'
+    ? pluginGrants(getDb(), pluginKey)
+    : unavailablePluginGrants('this board is running on in-memory sample data')
+}
+
+export function dataFor(pluginKey: string): PluginData {
+  return env.DATA_SOURCE === 'postgres'
+    ? pluginData(getDb(), pluginKey, { statementTimeoutMs: REQUEST_STATEMENT_TIMEOUT_MS })
+    : unavailablePluginData('this board is running on in-memory sample data')
+}
+
+export function usersFor(): PluginUsers {
+  return env.DATA_SOURCE === 'postgres'
+    ? pluginUsers(getDb())
+    : unavailablePluginUsers('this board is running on in-memory sample data')
+}
+
+export function notifyFor(pluginKey: string): PluginNotify {
+  const entry = (forumConfig.plugins ?? []).find((candidate) => candidate.key === pluginKey)
+  const definition = entry?.plugin as PluginDefinition | undefined
+  const service = notificationService()
+
+  if (definition === undefined || service === null) {
+    return unavailablePluginNotify('this board is running on in-memory sample data')
+  }
+  return pluginNotify(pluginKey, definition.notifications ?? [], service)
+}
+
+export function runtimeContextFor(
+  pluginKey: string,
+  definition: PluginDefinition,
+  overrides: ReadonlyMap<string, string>,
+  log: ReturnType<typeof logger>,
+): PluginRuntimeContext {
+  return {
+    settings: resolvePluginSettings(definition, overrides, readPluginEnv),
+    logger: {
+      info: (message, detail) => log.info(detail ?? {}, message),
+      warn: (message, detail) => log.warn(detail ?? {}, message),
+      error: (message, detail) => log.error(detail ?? {}, message),
+    },
+    grants: grantsFor(pluginKey),
+    data: dataFor(pluginKey),
+    users: usersFor(),
+    notify: notifyFor(pluginKey),
+  }
+}
+
+export interface RenderedPluginPage {
+  readonly title: string
+  readonly node: ReactNode | null
+}
+
+export interface BoardPageRequest {
+  readonly viewer: { readonly userId: number | null; readonly isGuest: boolean }
+  readonly query: Readonly<Record<string, string>>
+  readonly boardUrl: string
+}
+
+export type BoardPageResult =
+  | { readonly outcome: 'rendered'; readonly title: string; readonly node: ReactNode | null }
+  | { readonly outcome: 'missing' }
+  | { readonly outcome: 'sign-in-first'; readonly title: string }
+
+function translated(
+  t: Awaited<ReturnType<typeof getTranslator>> | undefined,
+  key: string | undefined,
+  fallback: string,
+  args?: Parameters<Awaited<ReturnType<typeof getTranslator>>['t']>[1],
+): string {
+  return t !== undefined && key !== undefined && t.has(key) ? t.t(key, args) : fallback
+}
+
+export function pluginBoardPageTitle(
+  pluginKey: string,
+  path: string,
+  t?: Awaited<ReturnType<typeof getTranslator>>,
+): string | null {
+  const entry = (forumConfig.plugins ?? []).find((candidate) => candidate.key === pluginKey)
+  const definition = entry?.plugin as PluginDefinition | undefined
+  const page = (definition?.pages ?? []).find((candidate) => candidate.path === path)
+  return page === undefined ? null : translated(t, page.titleKey, page.title, page.titleArgs)
+}
+
+export async function renderPluginBoardPage(
+  pluginKey: string,
+  path: string,
+  request: BoardPageRequest,
+): Promise<BoardPageResult> {
+  const entry = (forumConfig.plugins ?? []).find((candidate) => candidate.key === pluginKey)
+  const definition = entry?.plugin as PluginDefinition | undefined
+
+  if (entry === undefined || definition === undefined) return { outcome: 'missing' }
+  if (entry.enabled === false) return { outcome: 'missing' }
+
+  const page = (definition.pages ?? []).find((candidate) => candidate.path === path)
+  if (page === undefined) return { outcome: 'missing' }
+
+  const overrides = await getSettingOverrides()
+  if (overrides.get(`plugin.${pluginKey}._enabled`) === '0') return { outcome: 'missing' }
+
+  const [log, t] = [logger({ component: 'plugin-page', plugin: pluginKey }), await getTranslator()]
+  const title = translated(t, page.titleKey, page.title, page.titleArgs)
+
+  if (page.access === 'member' && request.viewer.userId === null) {
+    return { outcome: 'sign-in-first', title }
+  }
+
+  try {
+    return {
+      outcome: 'rendered',
+      title,
+      node: await page.render({
+        ...runtimeContextFor(pluginKey, definition, overrides, log),
+        viewer: request.viewer,
+        path,
+        query: request.query,
+        boardUrl: request.boardUrl,
+        locale: t.locale,
+        t,
+      }),
+    }
+  } catch (error) {
+    log.error({ err: error, path }, 'plugin board page failed to render')
+    return { outcome: 'rendered', title, node: null }
+  }
+}
+
+export async function renderPluginAdminPage(
+  pluginKey: string,
+  path: string,
+  query: Readonly<Record<string, string>> = {},
+): Promise<RenderedPluginPage | null> {
+  const entry = (forumConfig.plugins ?? []).find((candidate) => candidate.key === pluginKey)
+  const definition = entry?.plugin as PluginDefinition | undefined
+
+  if (entry === undefined || definition === undefined) return null
+  if (entry.enabled === false) return null
+
+  const page = (definition.adminPages ?? []).find((candidate) => candidate.path === path)
+  if (page === undefined) return null
+
+  const overrides = await getSettingOverrides()
+  if (overrides.get(`plugin.${pluginKey}._enabled`) === '0') return null
+
+  const [log, t] = [logger({ component: 'plugin-page', plugin: pluginKey }), await getTranslator()]
+  const title = translated(t, page.titleKey, page.title, page.titleArgs)
+
+  try {
+    return {
+      title,
+      node: await page.render({
+        ...runtimeContextFor(pluginKey, definition, overrides, log),
+        query,
+        locale: t.locale,
+        t,
+      }),
+    }
+  } catch (error) {
+    log.error({ err: error, path }, 'plugin admin page failed to render')
+    return { title, node: null }
+  }
+}

package/src/server/plugin-panel.ts

@@ -0,0 +1,49 @@
+import 'server-only'
+
+import forumConfig from '@board/config'
+
+import type { Translator } from '@meith/i18n'
+import { type PluginDefinition, pluginAdminPath } from '@meith/plugin-kit'
+
+import type { PluginPage } from '@/view/plugin-panel'
+
+import { getSettingOverrides } from './settings'
+
+export interface PluginPanelSection {
+  readonly key: string
+  readonly name: string
+  readonly pages: readonly PluginPage[]
+}
+
+export async function pluginPanelSection(
+  pluginKey: string,
+  t?: Translator,
+): Promise<PluginPanelSection | null> {
+  const entry = (forumConfig.plugins ?? []).find((candidate) => candidate.key === pluginKey)
+  const definition = entry?.plugin as PluginDefinition | undefined
+
+  if (entry === undefined || definition === undefined) return null
+  if (entry.enabled === false) return null
+
+  const pages = definition.adminPages ?? []
+  if (pages.length === 0) return null
+
+  const overrides = await getSettingOverrides()
+  if (overrides.get(`plugin.${pluginKey}._enabled`) === '0') return null
+
+  return {
+    key: pluginKey,
+    name:
+      t !== undefined && definition.nameKey !== undefined && t.has(definition.nameKey)
+        ? t.t(definition.nameKey)
+        : definition.name,
+    pages: pages.map((page) => ({
+      path: page.path,
+      title:
+        t !== undefined && page.titleKey !== undefined && t.has(page.titleKey)
+          ? t.t(page.titleKey, page.titleArgs)
+          : page.title,
+      href: pluginAdminPath(pluginKey, page.path),
+    })),
+  }
+}

package/src/server/plugin-routes.ts

@@ -0,0 +1,298 @@
+import { tr } from './i18n'
+import 'server-only'
+
+import { env, logger, resolveClientAddress } from '@meith/core'
+import { currentRequestId } from '@meith/core/logger'
+import { demoAddressToken, demoDiscardsAddresses } from '@meith/demo'
+import {
+  createRouteRateLimiter,
+  DEFAULT_ROUTE_BODY_BYTES,
+  type PluginDefinition,
+  type PluginRequest,
+  type PluginResponse,
+  type PluginRoute,
+} from '@meith/plugin-kit'
+
+import { recordAdminAction, requireAdmin } from './admin'
+import { boardUrl } from './board-url'
+import { getActor } from './context'
+import { activeDefinitions, pluginHost, syncPluginEnablement } from './plugin-host'
+import { runtimeContextFor } from './plugin-pages'
+import { viewerRef } from './plugin-view'
+import { isSafeLocalPath } from './safe-path'
+import { isSameOrigin } from './same-origin'
+import { getSettingOverrides } from './settings'
+
+const STRIPPED_HEADERS = new Set(['cookie', 'authorization'])
+
+function json(body: unknown, status: number): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' },
+  })
+}
+
+function fail(status: number, code: string, message: string): Response {
+  return json({ error: { code, message, requestId: currentRequestId() ?? null } }, status)
+}
+
+function passedHeaders(request: Request): Readonly<Record<string, string>> {
+  const out: Record<string, string> = {}
+  request.headers.forEach((value, name) => {
+    const lower = name.toLowerCase()
+    if (STRIPPED_HEADERS.has(lower) || lower.startsWith('x-forum-')) return
+    out[lower] = value
+  })
+  return out
+}
+
+function queryOf(url: URL): Readonly<Record<string, string>> {
+  const out: Record<string, string> = {}
+  for (const [name, value] of url.searchParams) {
+    if (!(name in out)) out[name] = value
+  }
+  return out
+}
+
+interface ParsedBody {
+  readonly rawBody: Uint8Array | null
+  readonly form: Readonly<Record<string, string>> | null
+  readonly json: unknown
+}
+
+async function readBody(
+  request: Request,
+  route: PluginRoute,
+): Promise<ParsedBody | 'too-large' | 'unreadable'> {
+  if (route.method !== 'POST') return { rawBody: null, form: null, json: null }
+
+  const limit = route.maxBodyBytes ?? DEFAULT_ROUTE_BODY_BYTES
+
+  const declared = Number(request.headers.get('content-length') ?? '0')
+  if (Number.isFinite(declared) && declared > limit) return 'too-large'
+
+  let bytes: Uint8Array
+  try {
+    bytes = new Uint8Array(await request.arrayBuffer())
+  } catch {
+    return 'unreadable'
+  }
+  if (bytes.byteLength > limit) return 'too-large'
+
+  if (route.rawBody === true) return { rawBody: bytes, form: null, json: null }
+
+  const contentType = (request.headers.get('content-type') ?? '').toLowerCase()
+  const text = () => new TextDecoder().decode(bytes)
+
+  if (contentType.includes('application/json')) {
+    try {
+      return { rawBody: null, form: null, json: JSON.parse(text()) as unknown }
+    } catch {
+      return 'unreadable'
+    }
+  }
+
+  if (contentType.includes('application/x-www-form-urlencoded')) {
+    const form: Record<string, string> = {}
+    for (const [name, value] of new URLSearchParams(text())) {
+      if (!(name in form)) form[name] = value
+    }
+    return { rawBody: null, form, json: null }
+  }
+
+  return { rawBody: null, form: null, json: null }
+}
+
+function redirectAllowed(to: string, definition: PluginDefinition): boolean {
+  if (isSafeLocalPath(to)) return true
+
+  let url: URL
+  try {
+    url = new URL(to)
+  } catch {
+    return false
+  }
+
+  const hostname = url.hostname.toLowerCase()
+  const loopback = hostname === '127.0.0.1' || hostname === 'localhost' || hostname === '[::1]'
+  const scheme = url.protocol === 'https:' || (url.protocol === 'http:' && loopback)
+
+  return scheme && (definition.allowedRedirectHosts ?? []).includes(hostname)
+}
+
+function toResponse(
+  answer: PluginResponse,
+  method: 'GET' | 'POST',
+  definition: PluginDefinition,
+  pluginKey: string,
+): Response {
+  switch (answer.kind) {
+    case 'json':
+      return json(answer.body, answer.status ?? 200)
+
+    case 'text':
+      return new Response(answer.body, {
+        status: answer.status ?? 200,
+        headers: {
+          'content-type': answer.contentType ?? 'text/plain; charset=utf-8',
+          'cache-control': 'no-store',
+        },
+      })
+
+    case 'redirect': {
+      if (!redirectAllowed(answer.to, definition)) {
+        logger({ component: 'plugin-route', plugin: pluginKey }).error(
+          { to: answer.to },
+          'refused a redirect outside the plugin’s allowed hosts',
+        )
+        return fail(502, 'redirect_refused', 'The plugin answered with a redirect it may not make.')
+      }
+      return new Response(null, {
+        status: method === 'POST' ? 303 : 307,
+        headers: { location: answer.to, 'cache-control': 'no-store' },
+      })
+    }
+  }
+}
+
+const routeLimiter = createRouteRateLimiter()
+
+function callerKey(request: Request, userId: number | null): string {
+  if (userId !== null) return `u:${userId}`
+  const address = resolveClientAddress(
+    {
+      forwardedFor: request.headers.get('x-forwarded-for'),
+      realIp: request.headers.get('x-real-ip'),
+    },
+    env.TRUSTED_PROXY_HOPS,
+  )
+  if (address === null) return 'a:unknown'
+
+  return `a:${demoDiscardsAddresses() ? demoAddressToken(address) : address}`
+}
+
+export type PluginRouteSurface = 'board' | 'admin'
+
+export async function dispatchPluginRoute(
+  request: Request,
+  pluginKey: string,
+  segments: readonly string[],
+  surface: PluginRouteSurface = 'board',
+): Promise<Response> {
+  const definition = activeDefinitions().find((candidate) => candidate.key === pluginKey)
+  if (definition === undefined) {
+    return fail(404, 'no_such_route', 'No such endpoint.')
+  }
+
+  await syncPluginEnablement()
+  if (!pluginHost.isEnabled(pluginKey)) {
+    return fail(404, 'no_such_route', 'No such endpoint.')
+  }
+
+  const path = segments.join('/')
+  const method = request.method === 'POST' ? 'POST' : request.method === 'GET' ? 'GET' : null
+  if (method === null) {
+    return fail(405, 'method_not_allowed', 'Plugin routes answer GET and POST.')
+  }
+
+  const declared = (definition.routes ?? []).filter(
+    (candidate) =>
+      candidate.path === path && (candidate.access === 'admin') === (surface === 'admin'),
+  )
+  if (declared.length === 0) {
+    return fail(404, 'no_such_route', 'No such endpoint.')
+  }
+
+  const route = declared.find((candidate) => candidate.method === method)
+  if (route === undefined) {
+    return fail(405, 'method_not_allowed', `This endpoint answers ${declared[0]!.method}.`)
+  }
+
+  const actor = await getActor()
+  if (route.access === 'member' && actor.userId === null) {
+    return fail(401, 'unauthenticated', 'Sign in to use this.')
+  }
+
+  if (route.access === 'admin') {
+    try {
+      await requireAdmin()
+    } catch {
+      return fail(403, 'administrators_only', 'Enter the control panel and try again.')
+    }
+  }
+
+  if (route.access !== 'anonymous' && method === 'POST' && !isSameOrigin(request)) {
+    return fail(403, 'cross_origin', 'This form was posted from somewhere that is not the board.')
+  }
+
+  if (route.rateLimit !== undefined) {
+    const verdict = await routeLimiter.consume(
+      `${pluginKey}:${path}:${callerKey(request, actor.userId)}`,
+      route.rateLimit.limit,
+      route.rateLimit.windowSeconds,
+      Date.now(),
+    )
+    if (!verdict.allowed) {
+      return new Response(
+        JSON.stringify({
+          error: {
+            code: 'rate_limited',
+            message: await tr('notice.app.too-many-calls-endpoint-give'),
+            requestId: currentRequestId() ?? null,
+          },
+        }),
+        {
+          status: 429,
+          headers: {
+            'content-type': 'application/json; charset=utf-8',
+            'cache-control': 'no-store',
+            'retry-after': String(verdict.retryAfterSeconds),
+          },
+        },
+      )
+    }
+  }
+
+  const body = await readBody(request, route)
+  if (body === 'too-large') {
+    return fail(413, 'body_too_large', 'The request body is over this endpoint’s limit.')
+  }
+  if (body === 'unreadable') {
+    return fail(400, 'unreadable_body', 'The request body could not be read as declared.')
+  }
+
+  const url = new URL(request.url)
+  const pluginRequest: PluginRequest = {
+    viewer: viewerRef(actor),
+    method,
+    path,
+    query: queryOf(url),
+    headers: passedHeaders(request),
+    rawBody: body.rawBody,
+    form: body.form,
+    json: body.json,
+    boardUrl: await boardUrl(),
+  }
+
+  const overrides = await getSettingOverrides()
+  const log = logger({ component: 'plugin-route', plugin: pluginKey })
+
+  const outcome = await pluginHost.run(pluginKey, `route ${method} ${path}`, () =>
+    route.handler(pluginRequest, {
+      ...runtimeContextFor(pluginKey, definition, overrides, log),
+    }),
+  )
+
+  if (outcome.status === 'disabled') {
+    return fail(404, 'no_such_route', 'No such endpoint.')
+  }
+  if (outcome.status === 'failed' || outcome.value === undefined || outcome.value === null) {
+    return fail(500, 'plugin_failed', 'The plugin could not answer. The error is in the log.')
+  }
+
+  if (route.access === 'admin' && method === 'POST') {
+    await recordAdminAction({ action: 'plugin.route', detail: { plugin: pluginKey, path } })
+  }
+
+  return toResponse(outcome.value, method, definition, pluginKey)
+}

package/src/server/plugin-view.tsx

@@ -0,0 +1,58 @@
+import 'server-only'
+
+import { Fragment } from 'react'
+
+import type { Actor } from '@meith/authorization'
+import type {
+  HookContext,
+  HookName,
+  HookValue,
+  PluginRegion,
+  PluginRegionContext,
+} from '@meith/plugin-kit'
+
+import { pluginHost, syncPluginEnablement } from './plugin-host'
+
+export function viewerRef(actor: Actor): { userId: number | null; isGuest: boolean } {
+  return { userId: actor.userId, isGuest: actor.userId === null }
+}
+
+export async function filterView<K extends HookName>(
+  name: K,
+  value: HookValue<K>,
+  context: HookContext<K>,
+): Promise<HookValue<K>> {
+  await syncPluginEnablement()
+  return pluginHost.applyFilter(name, value, context)
+}
+
+export async function emitEvent<K extends HookName>(
+  name: K,
+  value: HookValue<K>,
+  context: HookContext<K>,
+): Promise<void> {
+  await syncPluginEnablement()
+  await pluginHost.emit(name, value, context)
+}
+
+export async function pluginRegion(
+  region: PluginRegion,
+  context: Omit<PluginRegionContext, 'region'>,
+): Promise<React.ReactNode> {
+  await syncPluginEnablement()
+
+  const nodes = pluginHost.renderRegion(region, { ...context, region })
+  if (nodes.length === 0) return null
+
+  return (
+    <>
+      {nodes.map((entry) => (
+        <Fragment key={entry.key}>{entry.node}</Fragment>
+      ))}
+    </>
+  )
+}
+
+export async function boardRegion(region: PluginRegion, actor: Actor): Promise<React.ReactNode> {
+  return pluginRegion(region, { viewer: viewerRef(actor), subjectId: null, authorId: null })
+}

package/src/server/poll-actions.ts

@@ -0,0 +1,104 @@
+'use server'
+
+import { redirect } from 'next/navigation'
+
+import { ForbiddenError, ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+import { type PollEditOption, PollService } from '@meith/polls'
+
+import { getContainer } from './container'
+import { getActor } from './context'
+import { emitEvent, viewerRef } from './plugin-view'
+import { resolvePollScope } from './poll-scope'
+
+function id(form: FormData, name: string): number {
+  const value = Number(form.get(name))
+  if (!Number.isSafeInteger(value) || value <= 0)
+    throw new ValidationError(msg('error.app.poll-exist'))
+  return value
+}
+
+function optionIds(form: FormData): readonly number[] {
+  return form
+    .getAll('optionId')
+    .map((value) => Number(value))
+    .filter((value) => Number.isSafeInteger(value) && value > 0)
+}
+
+function text(form: FormData, name: string): string {
+  const value = form.get(name)
+  return typeof value === 'string' ? value : ''
+}
+
+function closingTime(form: FormData): Date | null {
+  const value = text(form, 'closesAt').trim()
+  if (value === '') return null
+
+  const at = new Date(`${value}Z`)
+  if (Number.isNaN(at.getTime())) throw new ValidationError(msg('error.app.valid-date'))
+  return at
+}
+
+function editedOptions(form: FormData): readonly PollEditOption[] {
+  const labels = form.getAll('optionLabel')
+  return form.getAll('optionRef').flatMap((reference, index) => {
+    const label = labels[index]
+    if (typeof label !== 'string') return []
+    const raw = Number(reference)
+    const existing = Number.isSafeInteger(raw) && raw > 0 ? raw : null
+    return [{ id: existing, label }]
+  })
+}
+
+export async function votePollAction(form: FormData): Promise<void> {
+  const threadId = id(form, 'threadId')
+  const pollId = id(form, 'pollId')
+  const actor = await getActor()
+  const { polls } = getContainer()
+  if (polls === null || actor.userId === null)
+    throw new ForbiddenError(msg('error.app.must-logged-vote'))
+
+  const scope = await resolvePollScope(actor, threadId)
+  if (scope === null) throw new ValidationError(msg('error.app.poll-exist'))
+
+  const chosen = optionIds(form)
+  await new PollService(polls).vote({
+    threadId,
+    pollId,
+    optionIds: chosen,
+    userId: actor.userId,
+    mayVote: scope.mayVote,
+  })
+  for (const optionId of chosen) {
+    await emitEvent('poll.voted', { pollId, optionId }, viewerRef(actor))
+  }
+  redirect(`/thread/${threadId}`)
+}
+
+export async function editPollAction(form: FormData): Promise<void> {
+  const threadId = id(form, 'threadId')
+  const pollId = id(form, 'pollId')
+  const actor = await getActor()
+  const { polls } = getContainer()
+  if (polls === null || actor.userId === null)
+    throw new ForbiddenError(msg('error.app.must-logged-vote'))
+
+  const scope = await resolvePollScope(actor, threadId)
+  if (scope === null) throw new ValidationError(msg('error.app.poll-exist'))
+
+  await new PollService(polls).edit({
+    threadId,
+    pollId,
+    edit: {
+      question: text(form, 'question'),
+      options: editedOptions(form),
+      closesAt: closingTime(form),
+      maxOptions: Number(text(form, 'maxOptions')),
+      allowRevote: form.get('allowRevote') !== null,
+      publicVotes: form.get('publicVotes') !== null,
+    },
+    capabilities: scope.capabilities,
+  })
+
+  redirect(`/thread/${threadId}`)
+}