@meith/web 0.16.0

package/src/server/api/messages.ts

@@ -0,0 +1,113 @@
+import 'server-only'
+
+import { idParam } from '@meith/api'
+import { ValidationError } from '@meith/core'
+import { sourceAsMarkdown } from '@meith/markdown'
+import { parseFolder } from '@meith/messages'
+
+import { dailyLimitMessage, limitMessage, spendDailyLimit, spendLimit } from '../antispam'
+import { requireMessaging } from '../messages'
+import { type ApiResult, type ApiRoutes, bodyFlag, bodyId, bodyText, notFound } from './http'
+
+export const MESSAGE_HANDLERS: ApiRoutes = [
+  [
+    'GET',
+    '/messages',
+    async ({ actor, url }): Promise<ApiResult> => {
+      const { service, userId } = await requireMessaging(actor)
+      const folder = parseFolder(url.searchParams.get('folder') ?? '') ?? 'inbox'
+      const before = idParam(url.searchParams.get('before') ?? undefined)
+
+      const page = await service.list({
+        userId,
+        folder,
+        ...(before === null ? {} : { before }),
+      })
+
+      return {
+        status: 200,
+        body: {
+          data: page.rows.map((row) => ({
+            copyId: row.copyId,
+            messageId: row.messageId,
+            folder: row.folder,
+            role: row.role,
+            subject: row.subject,
+            sentAt: row.sentAt.toISOString(),
+            readAt: row.readAt === null ? null : row.readAt.toISOString(),
+            counterparties: [...row.counterparties],
+            moreCounterparties: row.moreCounterparties,
+          })),
+          nextBefore: page.nextBefore,
+        },
+      }
+    },
+  ],
+
+  [
+    'GET',
+    '/messages/:messageId',
+    async ({ actor, params }): Promise<ApiResult> => {
+      const messageId = idParam(params.messageId)
+      if (messageId === null) return notFound()
+
+      const { service, userId } = await requireMessaging(actor)
+      const detail = await service.open({ messageId, userId })
+
+      return {
+        status: 200,
+        body: {
+          data: {
+            id: detail.message.id,
+            copyId: detail.copy.id,
+            authorUserId: detail.message.authorUserId,
+            authorUsername: detail.message.authorUsername,
+            subject: detail.message.subject,
+            message: sourceAsMarkdown(detail.message.message, detail.message.bodyFormat),
+            folder: detail.copy.folder,
+            role: detail.copy.role,
+            receiptRequested: detail.message.receiptRequested,
+            replyToId: detail.message.replyToId,
+            sentAt: detail.message.sentAt.toISOString(),
+            readAt: detail.copy.readAt === null ? null : detail.copy.readAt.toISOString(),
+            participants: detail.participants.map((participant) => ({
+              userId: participant.userId,
+              username: participant.username,
+              role: participant.role,
+              readAt: participant.readAt === null ? null : participant.readAt.toISOString(),
+            })),
+          },
+        },
+      }
+    },
+  ],
+
+  [
+    'POST',
+    '/messages',
+    async ({ actor, body }): Promise<ApiResult> => {
+      const { service, userId, username } = await requireMessaging(actor)
+
+      const limited = await spendLimit({ scope: 'message', actor })
+      if (limited !== null && !limited.allowed) throw new ValidationError(limitMessage(limited))
+
+      const daily = await spendDailyLimit({ scope: 'message_day', actor })
+      if (daily !== null && !daily.allowed) {
+        throw new ValidationError(dailyLimitMessage('message_day', daily))
+      }
+
+      const id = await service.send({
+        authorUserId: userId,
+        authorUsername: username,
+        to: bodyText(body, 'to'),
+        bcc: bodyText(body, 'bcc'),
+        subject: bodyText(body, 'subject'),
+        message: bodyText(body, 'message'),
+        receiptRequested: bodyFlag(body, 'receiptRequested'),
+        replyToId: bodyId(body, 'replyToId'),
+      })
+
+      return { status: 201, body: { data: { id } } }
+    },
+  ],
+]

package/src/server/api/registry.ts

@@ -0,0 +1,30 @@
+import 'server-only'
+
+import { ROUTES, type RouteKey, routeKey } from '@meith/api'
+
+import { CONTENT_HANDLERS } from './content'
+import type { ApiHandler, ApiRoutes } from './http'
+import { MEMBER_HANDLERS } from './members'
+import { MESSAGE_HANDLERS } from './messages'
+import { SEARCH_HANDLERS } from './search'
+import { SUBSCRIPTION_HANDLERS } from './subscriptions'
+
+const DECLARED: ApiRoutes = [
+  ...CONTENT_HANDLERS,
+  ...MEMBER_HANDLERS,
+  ...MESSAGE_HANDLERS,
+  ...SEARCH_HANDLERS,
+  ...SUBSCRIPTION_HANDLERS,
+]
+
+const HANDLERS = new Map<RouteKey, ApiHandler>(
+  DECLARED.map(([method, path, handler]) => [routeKey({ method, path }), handler]),
+)
+
+export function handlerFor(key: RouteKey): ApiHandler | null {
+  return HANDLERS.get(key) ?? null
+}
+
+export const IMPLEMENTED_ROUTES: readonly string[] = [...HANDLERS.keys()].sort()
+
+export const DECLARED_ROUTES: readonly string[] = ROUTES.map((route) => routeKey(route)).sort()

package/src/server/api/search.ts

@@ -0,0 +1,98 @@
+import 'server-only'
+
+import {
+  isRunnable,
+  parseSearchInput,
+  readGrouping,
+  readMatch,
+  readPeriod,
+  readSort,
+  type SearchCursor,
+  searchQueryFrom,
+} from '@meith/search'
+
+import { filterWords } from '../../view/word-filter'
+import { activeWordFilter } from '../content-admin'
+import { requireSearch, requireSearchEnabled, searchMinWordLength, searchScopeFor } from '../search'
+import {
+  type ApiResult,
+  type ApiRoutes,
+  badRequest,
+  decodeCursor,
+  encodeCursor,
+  pageLimit,
+} from './http'
+
+export const SEARCH_HANDLERS: ApiRoutes = [
+  [
+    'GET',
+    '/search',
+    async ({ actor, url }): Promise<ApiResult> => {
+      await requireSearchEnabled()
+
+      const minWordLength = await searchMinWordLength()
+      const parsed = parseSearchInput(url.searchParams.get('q') ?? '', minWordLength)
+
+      if (!isRunnable(parsed)) {
+        return badRequest(
+          parsed.refusal === 'too-short'
+            ? `That search term is too short — one word in it has to be at least ${minWordLength} characters.`
+            : parsed.refusal === 'too-long'
+              ? 'That search term is too long.'
+              : 'Provide a search term in ?q=.',
+        )
+      }
+
+      const ids = (key: string): readonly number[] | undefined => {
+        const values = url.searchParams
+          .getAll(key)
+          .map((value) => Number(value))
+          .filter((value) => Number.isSafeInteger(value) && value > 0)
+
+        return values.length === 0 ? undefined : values
+      }
+
+      const forumIds = ids('forum')
+      const authorUserIds = ids('by')
+
+      const results = await requireSearch().search(
+        searchQueryFrom(
+          parsed.terms,
+          {
+            sort: readSort(url.searchParams.get('sort')),
+            match: readMatch(url.searchParams.get('in')),
+            grouping: readGrouping(url.searchParams.get('show')),
+            period: readPeriod(url.searchParams.get('when')),
+            ...(forumIds === undefined ? {} : { forumIds }),
+            ...(authorUserIds === undefined ? {} : { authorUserIds }),
+          },
+          {
+            limit: pageLimit(url),
+            after: decodeCursor<SearchCursor>(url.searchParams.get('after')),
+            now: new Date(),
+          },
+        ),
+        await searchScopeFor(actor),
+      )
+
+      const wordFilter = await activeWordFilter()
+
+      return {
+        status: 200,
+        body: {
+          data: results.hits.map((hit) => ({
+            postId: hit.postId,
+            threadId: hit.threadId,
+            forumId: hit.forumId,
+            threadTitle: hit.threadTitle,
+            authorUserId: hit.authorUserId,
+            authorUsername: hit.authorUsername,
+            postedAt: hit.postedAt.toISOString(),
+            excerpt: filterWords(hit.excerpt, wordFilter),
+          })),
+          nextCursor: results.nextCursor === null ? null : encodeCursor(results.nextCursor),
+        },
+      }
+    },
+  ],
+]

package/src/server/api/subscriptions.ts

@@ -0,0 +1,106 @@
+import 'server-only'
+
+import { idParam } from '@meith/api'
+import type { Actor } from '@meith/authorization'
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+import { parseSubscriptionTarget, SubscriptionService } from '@meith/subscriptions'
+
+import { getContainer } from '../container'
+import { type ApiResult, type ApiRoutes, bodyId, bodyText, notFound, requireUserId } from './http'
+
+async function mayView(
+  actor: Actor,
+  target: 'thread' | 'forum',
+  targetId: number,
+): Promise<boolean> {
+  const { authorizer, threads, forums } = getContainer()
+
+  const located = target === 'forum' ? null : await threads.locate(targetId)
+  const forumId = target === 'forum' ? targetId : (located?.forumId ?? null)
+  if (forumId === null) return false
+
+  const forum = await forums.findById(forumId)
+  if (!forum) return false
+
+  const matrix = await authorizer.forumMatrix(actor, forumId)
+  return target === 'forum'
+    ? authorizer.can(actor, 'forum.view', { forumId, forum: matrix })
+    : authorizer.can(actor, 'thread.view', {
+        ...(await authorizer.moderatorTargetIn(actor, forumId, matrix)),
+        threadAuthorId: located?.authorUserId ?? null,
+      })
+}
+
+function requireSubscriptions(): SubscriptionService {
+  const { subscriptions } = getContainer()
+  if (subscriptions === null) {
+    throw new ValidationError(msg('error.app.board-running-in-memory-sample-data-17'))
+  }
+  return new SubscriptionService({ subscriptions })
+}
+
+export const SUBSCRIPTION_HANDLERS: ApiRoutes = [
+  [
+    'GET',
+    '/subscriptions',
+    async ({ actor }): Promise<ApiResult> => {
+      const userId = requireUserId(actor)
+      const visibleForumIds = await getContainer().authorizer.visibleForumIds(actor)
+      const rows = await requireSubscriptions().list(userId, visibleForumIds)
+
+      return {
+        status: 200,
+        body: {
+          data: rows.map((row) => ({
+            target: row.target,
+            targetId: row.targetId,
+            title: row.title,
+            href: row.href,
+            mode: row.mode,
+            createdAt: row.createdAt.toISOString(),
+            pending: row.pending,
+          })),
+        },
+      }
+    },
+  ],
+
+  [
+    'POST',
+    '/subscriptions',
+    async ({ actor, body }): Promise<ApiResult> => {
+      const userId = requireUserId(actor)
+      const target = parseSubscriptionTarget(bodyText(body, 'target'))
+      const targetId = bodyId(body, 'targetId')
+      if (target === null || targetId === null) return notFound()
+
+      const requested = bodyText(body, 'mode')
+
+      const mode = await requireSubscriptions().subscribe({
+        userId,
+        target,
+        targetId,
+        mode: requested === '' ? 'instant' : requested,
+        mayView: await mayView(actor, target, targetId),
+      })
+
+      return { status: 201, body: { data: { target, targetId, mode } } }
+    },
+  ],
+
+  [
+    'DELETE',
+    '/subscriptions/:target/:targetId',
+    async ({ actor, params }): Promise<ApiResult> => {
+      const userId = requireUserId(actor)
+      const target = parseSubscriptionTarget(params.target ?? '')
+      const targetId = idParam(params.targetId)
+      if (target === null || targetId === null) return notFound()
+
+      await requireSubscriptions().unsubscribe({ userId, target, targetId })
+
+      return { status: 200, body: { data: { target, targetId } } }
+    },
+  ],
+]

package/src/server/api-auth.ts

@@ -0,0 +1,66 @@
+import 'server-only'
+
+import {
+  type AnonymousRateLimitStore,
+  type ApiTokenRecord,
+  authenticateToken,
+  isScope,
+  type RateLimitStore,
+} from '@meith/api'
+import type { Actor } from '@meith/authorization'
+import { env, logger } from '@meith/core'
+import { getDb, PostgresApiTokenRepository, PostgresRateLimitStore } from '@meith/db'
+
+import { rateLimitStore } from './antispam'
+import { getContainer } from './container'
+import { countingPrefix } from './request-fingerprint'
+
+const ANONYMOUS_SCOPE = 'api_anon'
+
+export interface AuthenticatedToken {
+  readonly token: ApiTokenRecord
+  readonly limits: RateLimitStore
+}
+
+export async function apiToken(presented: string): Promise<AuthenticatedToken | null> {
+  if (env.DATA_SOURCE === 'fixture') return null
+
+  const db = getDb()
+  const repository = new PostgresApiTokenRepository(db, isScope)
+  const outcome = await authenticateToken(presented, repository, new Date())
+
+  if (!outcome.ok) {
+    logger().warn({ reason: outcome.reason }, 'api token rejected')
+    return null
+  }
+
+  await repository.touch(outcome.token.id, new Date()).catch(() => {})
+
+  return { token: outcome.token, limits: new PostgresRateLimitStore(db) }
+}
+
+export async function apiActor(userId: number): Promise<Actor | null> {
+  return getContainer().actorSource.buildForUser(userId)
+}
+
+export async function apiGuest(): Promise<Actor> {
+  return getContainer().actorSource.buildGuest()
+}
+
+export async function anonymousSubject(): Promise<string> {
+  return (await countingPrefix()) ?? 'unknown'
+}
+
+export function anonymousLimits(): AnonymousRateLimitStore | null {
+  const store = rateLimitStore()
+  if (store === null) return null
+
+  return {
+    async spend(subject, windowStart, cost) {
+      return store.spend({ scope: ANONYMOUS_SCOPE, subject }, windowStart, cost)
+    },
+    async peek(subject, windowStart) {
+      return store.peek({ scope: ANONYMOUS_SCOPE, subject }, windowStart)
+    },
+  }
+}

package/src/server/api-token-actions.ts

@@ -0,0 +1,85 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+
+import { isAppError, logger, publicMessageOf, ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+import { recordAdminAction, requireAdmin, requireFreshAdmin } from './admin'
+import { apiTokenStore, issueApiToken } from './api-tokens-admin'
+import type { FormState } from './auth-form-state'
+import { getMessageResolver, tr } from './i18n'
+
+function field(form: FormData, name: string): string {
+  const value = form.get(name)
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function expiryFrom(raw: string, now: number): Date | null {
+  if (raw === '') return null
+
+  const days = /^\d+$/.test(raw) ? Number(raw) : Number.NaN
+  if (!Number.isSafeInteger(days) || days <= 0) {
+    throw new ValidationError(msg('error.app.expires-days-must-whole-number'))
+  }
+
+  return new Date(now + days * 86_400_000)
+}
+
+function refreshTokenList(): void {
+  revalidatePath('/admin/api-tokens')
+}
+
+async function toState(err: unknown): Promise<FormState> {
+  if (isAppError(err)) return { error: publicMessageOf(err, await getMessageResolver()) }
+  logger({ module: 'api-token-actions' }).error({ err }, 'api token action failed')
+  return { error: await tr('notice.app.something-went-wrong-please-try') }
+}
+
+export async function issueApiTokenAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    const admin = await requireFreshAdmin()
+
+    const expiresAt = expiryFrom(field(form, 'expiresInDays'), Date.now())
+
+    const token = await issueApiToken({
+      userId: admin.userId,
+      name: field(form, 'name'),
+      scopes: form.getAll('scopes').filter((s): s is string => typeof s === 'string'),
+      expiresAt,
+    })
+
+    await recordAdminAction({
+      action: 'system.api_token_issued',
+      detail: { name: field(form, 'name') },
+    })
+
+    refreshTokenList()
+
+    return { notice: 'issued', values: { token } }
+  } catch (err) {
+    return toState(err)
+  }
+}
+
+export async function revokeApiTokenAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const id = Number(field(form, 'tokenId'))
+    if (!Number.isSafeInteger(id) || id <= 0) return { error: await tr('notice.app.such-token') }
+
+    const store = apiTokenStore()
+    if (store === null) return { error: await tr('notice.app.board-database-api') }
+
+    const revoked = await store.revoke(id, new Date())
+    if (revoked) {
+      await recordAdminAction({ action: 'system.api_token_revoked', detail: { tokenId: id } })
+    }
+
+    refreshTokenList()
+    return { notice: 'revoked' }
+  } catch (err) {
+    return toState(err)
+  }
+}

package/src/server/api-tokens-admin.ts

@@ -0,0 +1,95 @@
+import { msg } from '@meith/i18n'
+import 'server-only'
+
+import { isScope, issueToken, SCOPES, type Scope } from '@meith/api'
+import { ValidationError } from '@meith/core'
+import { type ApiTokenSummary, getDb, PostgresApiTokenRepository } from '@meith/db'
+
+import { getContainer } from './container'
+
+export function apiTokenStore(): PostgresApiTokenRepository | null {
+  return getContainer().dataSource === 'postgres'
+    ? new PostgresApiTokenRepository(getDb(), isScope)
+    : null
+}
+
+export interface ApiTokenRow {
+  readonly id: number
+  readonly name: string
+  readonly username: string
+  readonly lookup: string
+  readonly scopes: readonly string[]
+  readonly createdAt: Date
+  readonly expiresAt: Date | null
+  readonly lastUsedAt: Date | null
+  readonly state: 'live' | 'revoked' | 'expired'
+}
+
+export interface ApiTokenView {
+  readonly tokens: readonly ApiTokenRow[]
+  readonly scopes: readonly string[]
+}
+
+export async function buildApiTokenView(now: Date): Promise<ApiTokenView | null> {
+  const store = apiTokenStore()
+  if (store === null) return null
+
+  const rows = await store.listAll()
+  return {
+    tokens: rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      username: row.username,
+      lookup: row.lookup,
+      scopes: row.scopes,
+      createdAt: row.createdAt,
+      expiresAt: row.expiresAt,
+      lastUsedAt: row.lastUsedAt,
+      state: tokenState(row, now),
+    })),
+    scopes: SCOPES,
+  }
+}
+
+function tokenState(
+  row: Pick<ApiTokenSummary, 'revokedAt' | 'expiresAt'>,
+  now: Date,
+): ApiTokenRow['state'] {
+  if (row.revokedAt !== null) return 'revoked'
+  if (row.expiresAt !== null && row.expiresAt <= now) return 'expired'
+  return 'live'
+}
+
+export interface IssueTokenInput {
+  readonly userId: number
+  readonly name: string
+  readonly scopes: readonly string[]
+  readonly expiresAt: Date | null
+}
+
+export async function issueApiToken(input: IssueTokenInput): Promise<string> {
+  const store = apiTokenStore()
+  if (store === null) throw new ValidationError(msg('error.app.board-database-so-api'))
+
+  const name = input.name.trim()
+  if (name === '' || name.length > 80) {
+    throw new ValidationError(msg('error.app.give-token-name-1-80'))
+  }
+
+  const scopes = input.scopes.filter((scope): scope is Scope => isScope(scope))
+  if (scopes.length === 0) {
+    throw new ValidationError(msg('error.app.token-needs-at-least-one'))
+  }
+
+  const issued = issueToken()
+  await store.create({
+    userId: input.userId,
+    name,
+    lookup: issued.lookup,
+    secretHash: issued.secretHash,
+    scopes,
+    expiresAt: input.expiresAt,
+  })
+
+  return issued.token
+}

package/src/server/appearance-actions.ts

@@ -0,0 +1,39 @@
+'use server'
+
+import { cookies } from 'next/headers'
+
+import {
+  isColourScheme,
+  PREFERENCE_COOKIE_MAX_AGE,
+  SCHEME_COOKIE,
+  THEME_COOKIE,
+} from '@/view/theme-preference'
+
+import { redirectToCurrentPath } from './redirect-back'
+import { getBoardThemeStyle } from './theme-runtime'
+
+const COOKIE_OPTIONS = {
+  path: '/',
+  maxAge: PREFERENCE_COOKIE_MAX_AGE,
+  sameSite: 'lax',
+  httpOnly: false,
+} as const
+
+export async function setAppearanceAction(form: FormData): Promise<void> {
+  const jar = await cookies()
+
+  const scheme = form.get('scheme')
+  if (typeof scheme === 'string' && isColourScheme(scheme)) {
+    jar.set(SCHEME_COOKIE, scheme, COOKIE_OPTIONS)
+  }
+
+  const theme = form.get('theme')
+  if (typeof theme === 'string' && theme !== '') {
+    const { choices } = await getBoardThemeStyle()
+    if (choices.some((choice) => choice.key === theme)) {
+      jar.set(THEME_COOKIE, theme, COOKIE_OPTIONS)
+    }
+  }
+
+  await redirectToCurrentPath()
+}

package/src/server/attachment-download.ts

@@ -0,0 +1,43 @@
+import 'server-only'
+
+import { drivers } from '@meith/drivers'
+
+import { resolveDownload } from './attachments'
+import { getContainer } from './container'
+import { getActor } from './context'
+
+function notFound(): Response {
+  return new Response('Not found', { status: 404 })
+}
+
+function contentDisposition(filename: string): string {
+  const safe = filename.replace(/[^A-Za-z0-9._ -]/g, '_')
+  return `attachment; filename="${safe}"`
+}
+
+export async function serveAttachment(rawId: string, want: 'file' | 'thumb'): Promise<Response> {
+  if (!/^[1-9]\d*$/.test(rawId)) return notFound()
+
+  const actor = await getActor()
+  const grant = await resolveDownload(actor, Number(rawId), want)
+  if (grant === null) return notFound()
+
+  const bytes = await drivers().files.get(grant.key)
+  if (bytes === undefined) return notFound()
+
+  if (want === 'file') {
+    await getContainer().attachments?.recordDownload(grant.record.id)
+  }
+
+  return new Response(bytes as unknown as BodyInit, {
+    headers: {
+      'Content-Type': grant.contentType,
+      'Content-Length': String(bytes.byteLength),
+      'Content-Disposition': contentDisposition(grant.filename),
+      'X-Content-Type-Options': 'nosniff',
+      'Content-Security-Policy': "default-src 'none'; sandbox",
+      'X-Frame-Options': 'DENY',
+      'Cache-Control': 'private, max-age=0, must-revalidate',
+    },
+  })
+}