@meith/web 0.16.0

package/src/server/install.ts

@@ -0,0 +1,281 @@
+import 'server-only'
+
+import {
+  type AuthConfig,
+  DEFAULT_AUTH_POLICY,
+  IdentityService,
+  rejectedField,
+  resolveAuthPolicy,
+} from '@meith/accounts'
+import { env, GLOBAL_TAGS, logger } from '@meith/core'
+import {
+  canConnect as canConnectTo,
+  countUsers,
+  createPostgresAccountStore,
+  getDb,
+  isInstalled,
+  markInstalled,
+  PostgresAdminRepository,
+  PostgresForumRepository,
+  PostgresSettingsRepository,
+  runMigrations,
+  SEED_GROUP_KEY,
+  withInstallLock,
+} from '@meith/db'
+import { currentMailConfig, drivers } from '@meith/drivers'
+import {
+  type Check,
+  defaultForumSlug,
+  INSTALL_STEPS,
+  type InstallInput,
+  type MailProbe,
+  mailConfigFromInstallInput,
+  preflight,
+  type StepOutcome,
+} from '@meith/install'
+import {
+  canSendMail,
+  describeMailConfig,
+  mailConfigFromEnvironment,
+  SettingsSnapshot,
+  saveSettings,
+} from '@meith/settings'
+
+const INSTALLED_VERSION = '0.1.0'
+
+const INSTALL_IN_FLIGHT = 'install.raced.inFlight'
+
+const INSTALL_RACED = 'install.raced.sealed'
+
+export async function gatherPreflight(): Promise<readonly Check[]> {
+  const dataSource = env.DATA_SOURCE === 'postgres' ? 'postgres' : 'fixture'
+  const databaseUrl = env.DATABASE_URL ?? null
+
+  let connected: boolean | null = null
+  let users: number | null = null
+  let installed = false
+
+  if (dataSource === 'postgres' && databaseUrl !== null && databaseUrl !== '') {
+    try {
+      const db = getDb()
+      connected = await canConnectTo(db)
+      if (connected) {
+        users = await countUsers(db)
+        installed = await isInstalled(db)
+      }
+    } catch (error) {
+      logger().warn({ err: String(error) }, 'install preflight could not reach the database')
+      connected = false
+    }
+  }
+
+  return preflight({
+    dataSource,
+    databaseUrl,
+    hasAuthSecret: (env.AUTH_SECRET ?? '') !== '',
+    hasTickSecret: (env.TICK_SECRET ?? '') !== '',
+    publicUrl: env.APP_URL ?? null,
+    mail: await probeMail(),
+    canConnect: connected,
+    pendingMigrations: null,
+    userCount: users,
+    alreadyInstalled: installed,
+  })
+}
+
+export async function probeMail(): Promise<MailProbe> {
+  const fromEnvironment = mailConfigFromEnvironment(env)
+
+  try {
+    const config = fromEnvironment ?? (await currentMailConfig())
+    return {
+      configured: canSendMail(config),
+      source: fromEnvironment === null ? 'board' : 'environment',
+      summary: describeMailConfig(config),
+    }
+  } catch (error) {
+    logger().warn({ err: String(error) }, 'install preflight could not read mail settings')
+    return {
+      configured: false,
+      source: fromEnvironment === null ? 'board' : 'environment',
+      summary: 'Not sending — messages are written to the server log',
+    }
+  }
+}
+
+export async function installerIsSealed(): Promise<boolean> {
+  if (env.DATA_SOURCE !== 'postgres') return false
+  try {
+    return await isInstalled(getDb())
+  } catch {
+    return false
+  }
+}
+
+async function forgetCachedBoard(): Promise<void> {
+  try {
+    await drivers().cache.invalidateTags(GLOBAL_TAGS)
+  } catch (error) {
+    logger().warn(
+      { err: String(error) },
+      'install could not clear the cache; restart the server if the board looks empty',
+    )
+  }
+}
+
+export type InstallRun = { readonly sealed: true } | { readonly report: readonly StepOutcome[] }
+
+export async function runInstall(input: InstallInput): Promise<InstallRun> {
+  const url = env.DATABASE_URL ?? ''
+
+  try {
+    const run = await withInstallLock(url, async (): Promise<InstallRun> => {
+      if (await isInstalled(getDb())) return { sealed: true }
+      return { report: await performInstall(input) }
+    })
+
+    return run ?? { report: [{ id: 'migrate', status: 'failed', error: INSTALL_IN_FLIGHT }] }
+  } finally {
+    await forgetCachedBoard()
+  }
+}
+
+async function performInstall(input: InstallInput): Promise<readonly StepOutcome[]> {
+  const report: StepOutcome[] = []
+  const db = getDb()
+
+  const step = async (id: string, body: () => Promise<void>): Promise<boolean> => {
+    try {
+      await body()
+      report.push({ id, status: 'done' })
+      return true
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      logger().error({ step: id, err: message }, 'install step failed')
+      const field = rejectedField(error)
+      report.push({
+        id,
+        status: 'failed',
+        error: message.slice(0, 300),
+        ...(field === null ? {} : { field }),
+      })
+      return false
+    }
+  }
+
+  if (!(await step('migrate', async () => void (await runMigrations())))) return report
+
+  const settings = new PostgresSettingsRepository(db)
+  if (
+    !(await step('settings', async () => {
+      await settings.save(
+        new Map([
+          ['board.name', input.boardName],
+          ['board.url', input.boardUrl],
+        ]),
+      )
+
+      const mail = mailConfigFromInstallInput(input)
+      if (mail.transport === 'log') return
+
+      await saveSettings(
+        settings,
+        mail.transport === 'http'
+          ? {
+              'mail.transport': 'http',
+              'mail.from': mail.from,
+              'mail.http_endpoint': mail.endpoint,
+              'mail.http_token': mail.token,
+            }
+          : {
+              'mail.transport': 'smtp',
+              'mail.from': mail.from,
+              'mail.smtp_host': mail.host,
+              'mail.smtp_port': mail.port,
+              'mail.smtp_security': mail.security,
+              'mail.smtp_username': mail.username,
+              'mail.smtp_password': mail.password,
+            },
+        SettingsSnapshot.fromOverrides(await settings.loadAll()),
+      )
+    }))
+  ) {
+    return report
+  }
+
+  const admin = new PostgresAdminRepository(db)
+  let adminUserId: number | null = null
+
+  if (
+    !(await step('admin', async () => {
+      const registered = await admin.findGroup(SEED_GROUP_KEY.registered)
+      const administrator = await admin.findGroup(SEED_GROUP_KEY.administrators)
+      if (registered === null || administrator === null) {
+        const missing =
+          registered === null ? SEED_GROUP_KEY.registered : SEED_GROUP_KEY.administrators
+        const present = await admin.listGroupKeys()
+        throw new Error(
+          `No usergroup has the key "${missing}". ` +
+            (present.length === 0
+              ? 'The usergroups table is empty, so the seed migration did not run.'
+              : `The board has: ${present.join(', ')}.`),
+        )
+      }
+
+      const stored = SettingsSnapshot.fromOverrides(await settings.loadAll())
+
+      const config: AuthConfig = {
+        ...DEFAULT_AUTH_POLICY,
+        ...resolveAuthPolicy((key) => stored.get(key as never), {
+          ...DEFAULT_AUTH_POLICY,
+          activationMethod: 'none',
+        }),
+        registrationEnabled: true,
+        activationMethod: 'none',
+        defaultMemberGroupId: registered.id,
+      }
+
+      const identity = new IdentityService({ store: createPostgresAccountStore(db), config })
+      const result = await identity.register({
+        username: input.username,
+        email: input.email,
+        password: input.password,
+      })
+
+      await admin.setPrimaryGroup(result.account.id, administrator.id)
+      adminUserId = result.account.id
+    }))
+  ) {
+    return report
+  }
+
+  const forums = new PostgresForumRepository(db)
+  if (
+    !(await step('forum', async () => {
+      const category = await forums.create({
+        type: 'category',
+        title: input.boardName,
+        slug: defaultForumSlug(input.boardName),
+        parentId: null,
+      })
+      await forums.create({
+        type: 'forum',
+        title: 'General discussion',
+        slug: 'general-discussion',
+        description: 'Anything that does not fit elsewhere.',
+        parentId: category.id,
+      })
+    }))
+  ) {
+    return report
+  }
+
+  await step('seal', async () => {
+    if (!(await markInstalled(db, INSTALLED_VERSION))) throw new Error(INSTALL_RACED)
+  })
+
+  logger().info({ adminUserId, steps: report.length }, 'board installed')
+  return report
+}
+
+export { INSTALL_STEPS }

package/src/server/legacy-redirect.ts

@@ -0,0 +1,83 @@
+import 'server-only'
+
+import { notFound, permanentRedirect } from 'next/navigation'
+
+import { env } from '@meith/core'
+import { getDb, resolveLegacyId } from '@meith/db'
+import { type LegacyTarget, legacyRedirectPath, resolveLegacyUrl } from '@meith/import'
+
+import { getContainer } from './container'
+import { getSettings } from './settings'
+
+type Kind = 'thread' | 'forum' | 'post' | 'user'
+
+const LEGACY_KIND: Readonly<Record<Kind, 'thread' | 'forum' | 'post' | 'user'>> = {
+  thread: 'thread',
+  forum: 'forum',
+  post: 'post',
+  user: 'user',
+}
+
+export type LegacyScript =
+  | 'showthread.php'
+  | 'forumdisplay.php'
+  | 'member.php'
+  | 'viewtopic.php'
+  | 'viewforum.php'
+  | 'memberlist.php'
+
+function searchStringOf(params: Record<string, string | string[] | undefined>): string {
+  const search = new URLSearchParams()
+
+  for (const [key, value] of Object.entries(params)) {
+    if (value === undefined) continue
+    if (Array.isArray(value)) for (const item of value) search.append(key, item)
+    else search.append(key, value)
+  }
+
+  const rendered = search.toString()
+  return rendered === '' ? '' : `?${rendered}`
+}
+
+export async function legacyDestination(
+  pathname: string,
+  searchParams: Record<string, string | string[] | undefined>,
+): Promise<string | null> {
+  if (env.DATA_SOURCE !== 'postgres') return null
+
+  const settings = await getSettings()
+  if (settings.get('board.legacy_redirects') !== true) return null
+
+  const target = resolveLegacyUrl(pathname, searchStringOf(searchParams))
+  if (target === null) return null
+
+  if (target.kind === 'home') return '/'
+
+  const newId = await resolveLegacyId(getDb(), LEGACY_KIND[target.kind], target.legacyId)
+  if (newId === null) return null
+
+  return legacyRedirectPath(target, newId, await slugFor(target, newId))
+}
+
+export async function serveLegacyUrl(
+  script: LegacyScript,
+  searchParams: Record<string, string | string[] | undefined>,
+): Promise<never> {
+  const path = await legacyDestination(`/${script}`, searchParams)
+  if (path === null) notFound()
+
+  permanentRedirect(path)
+}
+
+async function slugFor(target: LegacyTarget, newId: number): Promise<string | null> {
+  try {
+    const { forums } = getContainer()
+    if (target.kind === 'forum') {
+      const all = await forums.listAll()
+      return all.find((forum) => forum.id === newId)?.slug ?? null
+    }
+    return null
+  } catch {
+    return null
+  }
+}

package/src/server/legal.ts

@@ -0,0 +1,43 @@
+import 'server-only'
+
+import { renderMarkdown } from '@meith/markdown'
+import type { LinkModel } from '@meith/theme-kit'
+
+import { buildLegalLinks, isPublished, type LegalPage, legalPage, TERMS_PAGE } from '../view/legal'
+import { getTranslator } from './i18n'
+import { getSettings } from './settings'
+
+export interface LegalDocument {
+  readonly title: string
+  readonly href: string
+  readonly bodyHtml: string
+}
+
+async function bodyOf(page: LegalPage): Promise<string> {
+  return (await getSettings()).get(page.settingKey)
+}
+
+export async function legalDocument(slug: string): Promise<LegalDocument | null> {
+  const page = legalPage(slug)
+  if (page === null) return null
+
+  const body = await bodyOf(page)
+  if (!isPublished(body)) return null
+
+  return {
+    title: (await getTranslator()).t(page.titleKey),
+    href: page.href,
+    bodyHtml: renderMarkdown(body, { headingOffset: 0 }).html,
+  }
+}
+
+export async function legalFooterLinks(): Promise<readonly LinkModel[]> {
+  const settings = await getSettings()
+  return buildLegalLinks((page) => settings.get(page.settingKey), await getTranslator())
+}
+
+export async function termsAcceptance(): Promise<LinkModel | null> {
+  return isPublished(await bodyOf(TERMS_PAGE))
+    ? { label: (await getTranslator()).t(TERMS_PAGE.titleKey), href: TERMS_PAGE.href }
+    : null
+}

package/src/server/location-header.ts

@@ -0,0 +1,37 @@
+export const PATH_HEADER = 'x-forum-path'
+
+/**
+ * The query string that came with `PATH_HEADER`, leading `?` included, or
+ * absent when there was none.
+ *
+ * Separate from the path because the path has readers that must not see a
+ * query: a presence row records where somebody is, and `/admin/settings` is one
+ * place however many groups it can be filtered by. The panel rail is the reader
+ * that needs both — its settings sections differ only by `?group=`, so a rail
+ * given the path alone cannot say which one is open.
+ */
+export const QUERY_HEADER = 'x-forum-query'
+
+/**
+ * Set by the middleware when it has just minted the guest cookie, meaning the
+ * client has not sent one back yet.
+ *
+ * It exists because the obvious test does not work: a cookie set on a
+ * `NextResponse.next()` response is reflected into the request the render sees,
+ * so neither `cookies()` nor the raw `Cookie` header can tell "the client kept
+ * this" from "we made it up a millisecond ago". Without the distinction every
+ * request from something that discards cookies wrote a presence row, which
+ * measured as twelve rows from twelve crawler requests.
+ *
+ * The middleware sets it or deletes it on every request, so a client cannot
+ * supply its own.
+ */
+export const FRESH_GUEST_HEADER = 'x-forum-fresh-guest'
+
+/**
+ * The per-request Content-Security-Policy nonce minted by `proxy.ts`, for the
+ * handful of inline `<script>` tags the app emits itself. Next reads the nonce
+ * out of the policy header on its own; this one is for our tags. See
+ * `docs/operating.md`.
+ */
+export const NONCE_HEADER = 'x-nonce'

package/src/server/mail-brand.ts

@@ -0,0 +1,43 @@
+import 'server-only'
+
+import { cache } from 'react'
+
+import type { Translator } from '@meith/i18n'
+import { buildMailBrand, type MailBrand } from '@meith/mail'
+
+import { boardUrl } from './board-url'
+import { getSettings } from './settings'
+import { getBoardThemeStyle } from './theme-runtime'
+
+export const mailBrand = cache(async (): Promise<MailBrand> => {
+  const [settings, origin, theme] = await Promise.all([
+    getSettings(),
+    boardUrl(),
+    getBoardThemeStyle(),
+  ])
+
+  const boardName = settings.get('board.name')
+  const alt = settings.get('board.logo_alt').trim()
+
+  return buildMailBrand({
+    boardName,
+    fromName: settings.get('mail.from_name'),
+    boardUrl: origin,
+    tokens: theme.defaultTokens,
+    logo: {
+      lightKey: settings.get('board.logo_light'),
+      darkKey: settings.get('board.logo_dark'),
+      alt: alt === '' ? boardName : alt,
+    },
+  })
+})
+
+export async function brandedFor(
+  t: Translator,
+  fallbackKey: string,
+): Promise<{ readonly brand: MailBrand; readonly boardName: string }> {
+  const brand = await mailBrand()
+  const boardName = brand.boardName === '' ? t.t(fallbackKey) : brand.boardName
+
+  return { brand: { ...brand, boardName }, boardName }
+}

package/src/server/mail-health.ts

@@ -0,0 +1,41 @@
+import 'server-only'
+
+import { env } from '@meith/core'
+import { currentMailConfig } from '@meith/drivers'
+import { canSendMail, describeMailConfig, type MailConfig, type MailSource } from '@meith/settings'
+
+import { boardAuthConfig } from './auth-config'
+
+export interface MailReadiness {
+  readonly config: MailConfig
+  readonly source: MailSource
+  readonly summary: string
+  readonly sends: boolean
+  readonly activationMethod: 'none' | 'email' | 'admin' | 'both'
+  readonly unactivatable: boolean
+}
+
+export async function assessMailReadiness(): Promise<MailReadiness> {
+  const { activationMethod } = await boardAuthConfig()
+
+  let config: MailConfig
+  try {
+    config = await currentMailConfig()
+  } catch {
+    config = { transport: 'log' }
+  }
+
+  const sends = canSendMail(config)
+
+  return {
+    config,
+    source: env.MAIL_DRIVER === 'log' ? 'board' : 'environment',
+    summary: describeMailConfig(config),
+    sends,
+    activationMethod,
+    unactivatable:
+      !sends &&
+      env.NODE_ENV !== 'development' &&
+      (activationMethod === 'email' || activationMethod === 'both'),
+  }
+}

package/src/server/mail-send.ts

@@ -0,0 +1,44 @@
+import 'server-only'
+
+import type { OutgoingMail } from '@meith/core'
+import { currentRequestId } from '@meith/core/logger'
+import { drivers } from '@meith/drivers'
+
+import { emitEvent, filterView } from './plugin-view'
+
+/**
+ * Every message the board sends from a request, past the plugins first. A
+ * plugin may rewrite the recipient, the subject or either body, or return null
+ * to drop the message — which is silent, because the member asked the board to
+ * do something and the board's answer is the page, not the mail.
+ */
+export async function sendBoardMail(template: string, mail: OutgoingMail): Promise<boolean> {
+  const proposed = await filterView(
+    'mail.send.before',
+    {
+      to: mail.to,
+      subject: mail.subject,
+      textBody: mail.text,
+      htmlBody: mail.html ?? null,
+    },
+    { template },
+  )
+
+  if (proposed === null) return false
+
+  await drivers().mail.send({
+    ...mail,
+    to: proposed.to,
+    subject: proposed.subject,
+    text: proposed.textBody,
+    ...(proposed.htmlBody === null ? {} : { html: proposed.htmlBody }),
+  })
+
+  await emitEvent(
+    'mail.sent',
+    { to: proposed.to, template },
+    { requestId: currentRequestId() ?? null },
+  )
+
+  return true
+}

package/src/server/mail-test-actions.ts

@@ -0,0 +1,67 @@
+'use server'
+
+import { isAppError, logger } from '@meith/core'
+import { currentMailConfig } from '@meith/drivers'
+import { canSendMail, describeMailConfig } from '@meith/settings'
+
+import { recordAdminAction, requireAdmin } from './admin'
+import type { FormState } from './auth-form-state'
+import { getContainer } from './container'
+import { getTranslator, tr } from './i18n'
+import { sendTestMail } from './mail-test'
+import { getSettings } from './settings'
+
+export async function sendTestMailAction(
+  _previous: FormState,
+  _form: FormData,
+): Promise<FormState> {
+  try {
+    const admin = await requireAdmin()
+    const t = await getTranslator()
+
+    const config = await currentMailConfig()
+    if (!canSendMail(config)) {
+      return {
+        error:
+          (await tr('notice.app.board-working-mail-configuration-there')) +
+          t.t('mailTest.currentConfiguration', { configuration: describeMailConfig(config) }),
+      }
+    }
+
+    const account = await getContainer().accountStore.accounts.findById(admin.userId)
+    if (account === null || account.email === '') {
+      return { error: await tr('notice.app.account-e-mail-address-send-test') }
+    }
+
+    const settings = await getSettings()
+    const result = await sendTestMail({
+      config,
+      to: account.email,
+      boardName: settings.get('board.name'),
+      t,
+      fromName: settings.get('mail.from_name'),
+    })
+
+    await recordAdminAction({
+      action: 'mail.tested',
+      detail: { ok: result.ok },
+    })
+
+    if (!result.ok) {
+      return {
+        error: t.t('mailTest.action.failed', {
+          error: result.error ?? '',
+          configuration: describeMailConfig(config),
+        }),
+      }
+    }
+
+    return {
+      notice: t.t('mailTest.action.sent', { email: account.email }),
+    }
+  } catch (error) {
+    if (isAppError(error)) return { error: error.message }
+    logger({ module: 'mail-test' }).error({ err: String(error) }, 'test send failed')
+    return { error: await tr('notice.app.test-could-run') }
+  }
+}

package/src/server/mail-test.ts

@@ -0,0 +1,56 @@
+import 'server-only'
+
+import { isAppError, logger } from '@meith/core'
+import { createMailDriver } from '@meith/drivers'
+import type { Translator } from '@meith/i18n'
+import { describeMailConfig, type MailConfig } from '@meith/settings'
+
+export interface MailTestResult {
+  readonly ok: boolean
+  readonly error?: string
+}
+
+export async function sendTestMail(input: {
+  readonly config: MailConfig
+  readonly to: string
+  readonly boardName: string
+  readonly t: Translator
+  readonly fromName?: string
+}): Promise<MailTestResult> {
+  const board =
+    input.boardName.trim() === '' ? input.t.t('mailTest.boardFallback') : input.boardName.trim()
+
+  try {
+    const driver = createMailDriver(input.config)
+
+    await driver.send({
+      to: input.to,
+      subject: `[${board}] ${input.t.t('mailTest.subject')}`,
+      text: [
+        input.t.t('mailTest.intro', { board }),
+        '',
+        input.t.t('mailTest.body'),
+        '',
+        input.t.t('mailTest.sentThrough', { configuration: describeMailConfig(input.config) }),
+      ].join('\n'),
+      ...(input.fromName === undefined || input.fromName.trim() === ''
+        ? {}
+        : { fromName: input.fromName }),
+    })
+
+    return { ok: true }
+  } catch (error) {
+    const message = isAppError(error)
+      ? error.message
+      : error instanceof Error
+        ? error.message
+        : String(error)
+
+    logger({ module: 'mail-test' }).warn(
+      { err: message, config: describeMailConfig(input.config) },
+      'test message could not be sent',
+    )
+
+    return { ok: false, error: message.slice(0, 400) }
+  }
+}