@meith/web 0.33.3 → 0.34.0

package/src/server/backup-admin.ts

@@ -0,0 +1,157 @@
+import 'server-only'
+
+import { stat } from 'node:fs/promises'
+import path from 'node:path'
+
+import {
+  type BackupCapability,
+  type BackupDestination,
+  type BackupRunRecord,
+  backupCapability,
+  backupDestinationFromEnv,
+  bundleTakenAt,
+  isBundleName,
+  localBundles,
+  nextSlotAfter,
+} from '@meith/backup'
+import { env, ForbiddenError, logger } from '@meith/core'
+import { getDb, PostgresBackupRunRepository } from '@meith/db'
+import { msg } from '@meith/i18n'
+import {
+  BACKUP_STALE_MS,
+  type BackupSettingsView,
+  backupDestinationFor,
+  backupRingDirectory,
+  loadBackupSettings,
+} from '@meith/runtime'
+
+import { getContainer } from './container'
+
+export interface BackupBundleRow {
+  readonly name: string
+  readonly takenAt: Date | null
+  readonly localSize: number | null
+  readonly remoteSize: number | null
+}
+
+export interface BackupDestinationView {
+  readonly source: 'environment' | 'board' | 'none'
+  readonly description: string | null
+  readonly problem: string | null
+  readonly listError: string | null
+}
+
+export interface BackupAdminView {
+  readonly capability: BackupCapability
+  readonly ring: string
+  readonly destination: BackupDestinationView
+  readonly bundles: readonly BackupBundleRow[]
+  readonly runs: readonly BackupRunRecord[]
+  readonly active: BackupRunRecord | null
+  readonly settings: BackupSettingsView
+  readonly nextScheduled: Date | null
+}
+
+const RECENT_RUNS = 10
+
+export function backupRuns(): PostgresBackupRunRepository | null {
+  return getContainer().dataSource === 'postgres' ? new PostgresBackupRunRepository(getDb()) : null
+}
+
+export function requireBackupRuns(): PostgresBackupRunRepository {
+  const runs = backupRuns()
+  if (runs === null) {
+    throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-6'))
+  }
+  return runs
+}
+
+export function backupRing(): string {
+  return backupRingDirectory(env)
+}
+
+export function backupsAvailable(): BackupCapability {
+  return backupCapability(env)
+}
+
+export function destinationIsFromEnvironment(): boolean {
+  try {
+    return backupDestinationFromEnv(env) !== undefined
+  } catch {
+    return true
+  }
+}
+
+export async function currentBackupSettings(): Promise<BackupSettingsView> {
+  return loadBackupSettings(getDb(), env)
+}
+
+export function destinationFor(settings: BackupSettingsView): BackupDestination | undefined {
+  return backupDestinationFor(settings.destination)
+}
+
+export async function localBundlePath(name: string): Promise<string | null> {
+  if (!isBundleName(name)) return null
+  const file = path.join(backupRing(), name)
+  const info = await stat(file).catch(() => null)
+  return info?.isFile() ? file : null
+}
+
+async function mergedBundles(
+  ring: string,
+  destination: BackupDestination | undefined,
+): Promise<{ readonly bundles: readonly BackupBundleRow[]; readonly listError: string | null }> {
+  const local = await localBundles(ring)
+  const rows = new Map<string, { localSize: number | null; remoteSize: number | null }>()
+  for (const bundle of local) rows.set(bundle.name, { localSize: bundle.size, remoteSize: null })
+
+  let listError: string | null = null
+  if (destination !== undefined) {
+    try {
+      for (const bundle of await destination.list()) {
+        const row = rows.get(bundle.name)
+        if (row === undefined) rows.set(bundle.name, { localSize: null, remoteSize: bundle.size })
+        else rows.set(bundle.name, { ...row, remoteSize: bundle.size })
+      }
+    } catch (error) {
+      listError = error instanceof Error ? error.message : String(error)
+      logger({ module: 'backup' }).warn({ err: listError }, 'could not list the off-site backups')
+    }
+  }
+
+  const bundles = [...rows]
+    .map(([name, sizes]) => ({ name, takenAt: bundleTakenAt(name), ...sizes }))
+    .sort((a, b) => b.name.localeCompare(a.name))
+  return { bundles, listError }
+}
+
+export async function buildBackupAdminView(now: Date): Promise<BackupAdminView | null> {
+  const runs = backupRuns()
+  if (runs === null) return null
+
+  const settings = await currentBackupSettings()
+  const destination = destinationFor(settings)
+  const ring = backupRing()
+
+  const [{ bundles, listError }, recent, active] = await Promise.all([
+    mergedBundles(ring, destination),
+    runs.recent(RECENT_RUNS),
+    runs.active(now, new Date(now.getTime() - BACKUP_STALE_MS)),
+  ])
+
+  return {
+    capability: backupsAvailable(),
+    ring,
+    destination: {
+      source: settings.destination.source,
+      description: destination?.description ?? null,
+      problem: settings.destination.problem,
+      listError,
+    },
+    bundles,
+    runs: recent,
+    active,
+    settings,
+    nextScheduled: nextSlotAfter(settings.schedule, now),
+  }
+}

package/src/server/backup-download.ts

@@ -0,0 +1,66 @@
+import 'server-only'
+
+import { createReadStream } from 'node:fs'
+import { stat } from 'node:fs/promises'
+import { Readable } from 'node:stream'
+
+import { isBundleName } from '@meith/backup'
+
+import { resolveAdmin } from './admin'
+import { currentBackupSettings, destinationFor, localBundlePath } from './backup-admin'
+
+export const BACKUPS_PATH = '/admin/system/backups'
+
+export const DOWNLOAD_LINK_SECONDS = 300
+
+function notFound(): Response {
+  return new Response('Not found', { status: 404 })
+}
+
+function seeOther(location: string): Response {
+  return new Response(null, { status: 303, headers: { Location: location } })
+}
+
+export async function serveBackupDownload(name: string): Promise<Response> {
+  if (!isBundleName(name)) return notFound()
+
+  const resolved = await resolveAdmin()
+  if ('denied' in resolved) return seeOther(BACKUPS_PATH)
+  if (resolved.context.needsReauth) return seeOther(`${BACKUPS_PATH}?notice=reauth`)
+
+  const local = await localBundlePath(name)
+  if (local !== null) {
+    const { size } = await stat(local)
+    const body = Readable.toWeb(createReadStream(local)) as unknown as BodyInit
+    return new Response(body, {
+      headers: {
+        'Content-Type': 'application/gzip',
+        'Content-Length': String(size),
+        'Content-Disposition': `attachment; filename="${name}"`,
+        'X-Content-Type-Options': 'nosniff',
+        'Cache-Control': 'private, no-store',
+      },
+    })
+  }
+
+  const destination = destinationFor(await currentBackupSettings())
+  if (destination === undefined) return notFound()
+  const listed = await destination.list()
+  if (!listed.some((bundle) => bundle.name === name)) return notFound()
+
+  if (destination.downloadUrl !== undefined) {
+    return seeOther(await destination.downloadUrl(name, DOWNLOAD_LINK_SECONDS))
+  }
+
+  const opened = await destination.open(name)
+  if (opened === null) return notFound()
+  return new Response(opened.body as unknown as BodyInit, {
+    headers: {
+      'Content-Type': 'application/gzip',
+      ...(opened.size === null ? {} : { 'Content-Length': String(opened.size) }),
+      'Content-Disposition': `attachment; filename="${name}"`,
+      'X-Content-Type-Options': 'nosniff',
+      'Cache-Control': 'private, no-store',
+    },
+  })
+}

package/src/server/install-restore-actions.ts

@@ -0,0 +1,40 @@
+'use server'
+
+import { isAppError, logger } from '@meith/core'
+
+import { getTranslator } from './i18n'
+import { installerIsSealed } from './install'
+import { type InstallRestoreOutcome, runInstallRestore } from './install-restore'
+
+export interface InstallRestoreState {
+  readonly error?: string
+  readonly outcome?: InstallRestoreOutcome
+}
+
+export async function installRestoreAction(
+  _previous: InstallRestoreState,
+  form: FormData,
+): Promise<InstallRestoreState> {
+  const t = await getTranslator()
+  if (await installerIsSealed()) return { error: t.t('installRestore.alreadyInstalled') }
+
+  const raw = form.get('bundle')
+  const name = typeof raw === 'string' ? raw.trim() : ''
+  if (name === '') return { error: t.t('installRestore.pickOne') }
+  if (form.get('confirm') !== '1') return { error: t.t('installRestore.confirmFirst') }
+
+  try {
+    const run = await runInstallRestore(name)
+    if ('sealed' in run) return { error: t.t('installRestore.alreadyInstalled') }
+    if ('busy' in run) return { error: t.t('installRestore.busy') }
+    return { outcome: run.outcome }
+  } catch (error) {
+    if (isAppError(error)) return { error: error.message }
+    logger({ module: 'install-restore' }).error({ err: error }, 'restore from the installer failed')
+    return {
+      error: t.t('installRestore.failed', {
+        error: error instanceof Error ? error.message.slice(0, 300) : String(error),
+      }),
+    }
+  }
+}

package/src/server/install-restore.ts

@@ -0,0 +1,186 @@
+import 'server-only'
+
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+
+import {
+  type BackupDestination,
+  backupCapability,
+  backupDestinationFromEnv,
+  bundleTakenAt,
+  isBundleName,
+  localBundles,
+  openBackupDestination,
+  type RestoreUploadsPlan,
+  restoreBackup,
+  restoreLimits,
+} from '@meith/backup'
+import { env, GLOBAL_TAGS, logger, processEnvironment, ValidationError } from '@meith/core'
+import {
+  countUsers,
+  getDb,
+  isInstalled,
+  migrationUrl,
+  runMigrations,
+  withInstallLock,
+} from '@meith/db'
+import { drivers } from '@meith/drivers'
+import { msg } from '@meith/i18n'
+import { backupRingDirectory } from '@meith/runtime'
+
+import { CODE_VERSION } from './upgrade-notice'
+
+export interface RestoreCandidate {
+  readonly name: string
+  readonly takenAt: Date | null
+  readonly size: number
+  readonly location: 'server' | 'off-site'
+}
+
+export interface InstallRestoreView {
+  readonly possible: boolean
+  readonly candidates: readonly RestoreCandidate[]
+  readonly ring: string
+  readonly destination: string | null
+  readonly problem: string | null
+}
+
+function offSiteDestination(): { destination: BackupDestination | null; problem: string | null } {
+  try {
+    const config = backupDestinationFromEnv(env)
+    return {
+      destination: config === undefined ? null : openBackupDestination(config),
+      problem: null,
+    }
+  } catch (error) {
+    return { destination: null, problem: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+export async function installRestoreView(): Promise<InstallRestoreView> {
+  const ring = backupRingDirectory(env)
+  if (backupCapability(env) !== 'available') {
+    return { possible: false, candidates: [], ring, destination: null, problem: null }
+  }
+
+  const { destination, problem } = offSiteDestination()
+  const candidates: RestoreCandidate[] = []
+  const seen = new Set<string>()
+
+  for (const bundle of await localBundles(ring).catch(() => [])) {
+    seen.add(bundle.name)
+    candidates.push({ ...bundle, takenAt: bundleTakenAt(bundle.name), location: 'server' })
+  }
+
+  let listProblem = problem
+  if (destination !== null) {
+    try {
+      for (const bundle of await destination.list()) {
+        if (seen.has(bundle.name)) continue
+        candidates.push({ ...bundle, takenAt: bundleTakenAt(bundle.name), location: 'off-site' })
+      }
+    } catch (error) {
+      listProblem = error instanceof Error ? error.message : String(error)
+      logger().warn({ err: listProblem }, 'the installer could not list the off-site backups')
+    }
+  }
+
+  return {
+    possible: true,
+    candidates: candidates.sort((a, b) => b.name.localeCompare(a.name)),
+    ring,
+    destination: destination?.description ?? null,
+    problem: listProblem,
+  }
+}
+
+function uploadsPlan(): RestoreUploadsPlan {
+  switch (env.FILESTORE_DRIVER) {
+    case 's3':
+      return { mode: 'store', store: drivers().files, description: `the ${env.S3_BUCKET} bucket` }
+    case 'blob':
+      return { mode: 'store', store: drivers().files, description: 'the Blob store' }
+    default:
+      return { mode: 'directory', dir: env.UPLOADS_DIR }
+  }
+}
+
+export interface InstallRestoreOutcome {
+  readonly bundle: string
+  readonly version: string
+  readonly posts: number
+  readonly migrationsApplied: number
+  readonly uploads: 'restored' | 'pushed' | 'skipped' | 'none'
+  readonly skippedKeys: number
+}
+
+export type InstallRestoreRun =
+  | { readonly sealed: true }
+  | { readonly outcome: InstallRestoreOutcome }
+  | { readonly busy: true }
+
+async function fetchCandidate(name: string, stage: string): Promise<string> {
+  const local = path.join(backupRingDirectory(env), name)
+  const known = await localBundles(backupRingDirectory(env)).catch(() => [])
+  if (known.some((bundle) => bundle.name === name)) return local
+
+  const { destination, problem } = offSiteDestination()
+  if (destination === null) {
+    throw new ValidationError(problem ?? msg('error.app.no-such-bundle').text)
+  }
+  const fetched = path.join(stage, name)
+  await destination.getToFile(name, fetched)
+  return fetched
+}
+
+export async function runInstallRestore(name: string): Promise<InstallRestoreRun> {
+  if (!isBundleName(name)) throw new ValidationError(msg('error.app.not-a-backup-bundle-name'))
+  if (backupCapability(env) !== 'available') {
+    throw new ValidationError(msg('error.app.backups-not-on-this-deployment'))
+  }
+
+  const url = migrationUrl(env)
+  const stage = await mkdtemp(path.join(tmpdir(), 'meith-install-restore-'))
+  try {
+    const run = await withInstallLock(url, async (): Promise<InstallRestoreRun> => {
+      const db = getDb()
+      if (await isInstalled(db)) return { sealed: true }
+      const members = await countUsers(db)
+      if (members !== null && members > 0) {
+        throw new ValidationError(msg('error.app.restore-needs-empty-board'))
+      }
+
+      const bundle = await fetchCandidate(name, stage)
+      const log = logger({ module: 'install-restore' })
+      const outcome = await restoreBackup({
+        bundle,
+        target: { url, variable: 'DATABASE_URL', mode: 'reset-schema' },
+        codeVersion: CODE_VERSION,
+        migrate: (target) => runMigrations({ url: target }),
+        uploads: uploadsPlan(),
+        limits: restoreLimits(processEnvironment()),
+        log: { info: (line) => log.info(line), warn: (line) => log.warn(line) },
+      })
+
+      return {
+        outcome: {
+          bundle: name,
+          version: outcome.manifest.version,
+          posts: outcome.posts,
+          migrationsApplied: outcome.migrationsApplied,
+          uploads: outcome.uploads,
+          skippedKeys: outcome.manifest.skippedKeys?.length ?? 0,
+        },
+      }
+    })
+    return run ?? { busy: true }
+  } finally {
+    await rm(stage, { recursive: true, force: true })
+    try {
+      await drivers().cache.invalidateTags(GLOBAL_TAGS)
+    } catch (error) {
+      logger().warn({ err: String(error) }, 'restore could not clear the cache; restart the server')
+    }
+  }
+}

package/src/server/upgrade-notice.ts

@@ -17,7 +17,7 @@ import { planUpgrade, type UpgradeState, upgradeNotice } from '@meith/upgrade'
 
 import { activeDefinitions } from './plugin-host'
 
-export const CODE_VERSION = '0.33.3'
+export const CODE_VERSION = '0.34.0'
 
 export interface UpgradeApplied {
   readonly plugins: readonly string[]

package/src/styles/globals.css

@@ -486,11 +486,11 @@
    * A permalink to `#post-12` otherwise lands the post flush against the top
    * of the viewport, with its own header cropped and the previous post's footer
    * nowhere — the reader cannot tell they arrived at the right one. The
-   * default theme's header is sticky — 3.5rem on a phone, 6.25rem with its
-   * navigation row on a desktop — so the margin clears it with room to spare.
+   * default theme's header is sticky and 3.5rem tall, so the margin clears it
+   * with room to spare.
    */
   :target {
-    scroll-margin-block-start: 7.5rem;
+    scroll-margin-block-start: 5rem;
   }
 
   ::selection {

package/src/view/admin-nav.ts

@@ -115,6 +115,7 @@ export const ADMIN_SECTIONS: PanelNav = [
     titleKey: 'adminNav.admin-system.title',
     icon: 'system',
     blurbKey: 'adminNav.admin-system.blurb',
+    children: [{ href: '/admin/system/backups', titleKey: 'adminNav.admin-system-backups.title' }],
   },
   {
     href: '/admin/log',

package/src/view/admin-panel-copy.ts

@@ -75,6 +75,22 @@ export function webhookFormsCopy(t: Translator = untranslated()): Readonly<Recor
   )
 }
 
+export function backupFormsCopy(t: Translator = untranslated()): Readonly<Record<string, string>> {
+  return {
+    ...copyFor(
+      [
+        'adminPanel.backup.now',
+        'adminPanel.backup.queued',
+        'adminPanel.backup.already',
+        'adminPanel.backup.delete',
+        'adminPanel.backup.test',
+      ],
+      t,
+    ),
+    ...patternCopy(['adminPanel.backup.deleted', 'adminPanel.backup.reachable'], t),
+  }
+}
+
 export function systemFormsCopy(t: Translator = untranslated()): Readonly<Record<string, string>> {
   return {
     ...copyFor(

package/src/view/install-copy.ts

@@ -96,3 +96,38 @@ export function installFormCopy(
     'install.mail.testNoteTail': testNoteTail,
   }
 }
+
+export function installRestoreCopy(
+  t: Translator = untranslated(),
+): Readonly<Record<string, string>> {
+  return {
+    ...copyFor(
+      [
+        'install.restore.title',
+        'install.restore.hint',
+        'install.restore.pick',
+        'install.restore.confirm',
+        'install.restore.submit',
+        'install.restore.restoring',
+        'install.restore.pendingNote',
+        'install.restore.idleNote',
+        'install.restore.notRestored',
+        'install.restore.noneLocal',
+        'install.restore.doneTitle',
+        'install.restore.noUploads',
+        'install.restore.next',
+        'install.restore.signIn',
+      ],
+      t,
+    ),
+    ...patternCopy(
+      [
+        'install.restore.noneAnywhere',
+        'install.restore.doneDetail',
+        'install.restore.migrated',
+        'install.restore.skipped',
+      ],
+      t,
+    ),
+  }
+}

package/src/view/navigation.ts

@@ -22,27 +22,36 @@ export interface BuiltInNavigationItem {
   readonly messageKey: string
   readonly href: string
   readonly audience: NavigationAudience
+  readonly shown: boolean
 }
 
 export const BUILT_IN_NAVIGATION: readonly BuiltInNavigationItem[] = [
-  { key: 'home', messageKey: 'nav.home', href: '/', audience: 'all' },
-  { key: 'new-posts', messageKey: 'nav.newPosts', href: '/discover/new', audience: 'all' },
+  { key: 'home', messageKey: 'nav.home', href: '/', audience: 'all', shown: true },
+  {
+    key: 'new-posts',
+    messageKey: 'nav.newPosts',
+    href: '/discover/new',
+    audience: 'all',
+    shown: true,
+  },
   {
     key: 'unanswered',
     messageKey: 'nav.unanswered',
     href: '/discover/unanswered',
     audience: 'all',
+    shown: false,
   },
   {
     key: 'my-posts',
     messageKey: 'nav.myPosts',
     href: '/discover/participated',
     audience: 'members',
+    shown: false,
   },
-  { key: 'search', messageKey: 'nav.search', href: '/search', audience: 'all' },
-  { key: 'online', messageKey: 'nav.online', href: '/online', audience: 'all' },
-  { key: 'members', messageKey: 'nav.members', href: '/members', audience: 'all' },
-  { key: 'staff', messageKey: 'nav.staff', href: '/staff', audience: 'all' },
+  { key: 'search', messageKey: 'nav.search', href: '/search', audience: 'all', shown: true },
+  { key: 'online', messageKey: 'nav.online', href: '/online', audience: 'all', shown: false },
+  { key: 'members', messageKey: 'nav.members', href: '/members', audience: 'all', shown: false },
+  { key: 'staff', messageKey: 'nav.staff', href: '/staff', audience: 'all', shown: false },
 ]
 
 const SEARCH_KEY = 'search'
@@ -64,7 +73,7 @@ export function defaultNavigationItems(): readonly NavigationItemRow[] {
     displayOrder: index * 10,
     audience: item.audience,
     newTab: false,
-    enabled: true,
+    enabled: item.shown,
     visibleToGroups: [],
   }))
 }

package/src/view/setting-groups.ts

@@ -12,6 +12,7 @@ export const GROUP_LABELS: Record<SettingGroup, string> = {
   federation: 'Sign-in providers',
   antispam: 'Anti-spam',
   push: 'Push',
+  backup: 'Backups',
   legal: 'Legal',
 }
 
@@ -27,6 +28,7 @@ export const GROUP_ORDER: readonly SettingGroup[] = [
   'federation',
   'antispam',
   'push',
+  'backup',
   'legal',
 ]