@meith/web 0.33.4 → 0.34.0

package/src/components/install/restore-form.tsx

@@ -0,0 +1,154 @@
+'use client'
+
+import { useActionState } from 'react'
+
+import {
+  Alert,
+  AlertDescription,
+  AlertTitle,
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from '@meith/ui'
+import { Button } from '@meith/ui/button'
+
+import { useFocusOnFail } from '@/components/auth/form-controls'
+import { type Copy, formatFromCopy, fromCopy } from '@/components/shell/copy'
+import { type InstallRestoreState, installRestoreAction } from '@/server/install-restore-actions'
+
+const EMPTY: InstallRestoreState = {}
+
+export interface RestoreCandidateView {
+  readonly name: string
+  readonly label: string
+  readonly size: string
+  readonly location: string
+}
+
+export function InstallRestoreForm({
+  candidates,
+  destination,
+  problem,
+  copy,
+}: {
+  candidates: readonly RestoreCandidateView[]
+  destination: string | null
+  problem: string | null
+  copy: Copy
+}) {
+  const [state, submit, pending] = useActionState(installRestoreAction, EMPTY)
+  const errorRef = useFocusOnFail<HTMLDivElement>(state.error !== undefined)
+
+  if (state.outcome !== undefined) {
+    const { outcome } = state
+    return (
+      <Card>
+        <CardHeader>
+          <CardTitle>{fromCopy(copy, 'install.restore.doneTitle')}</CardTitle>
+          <CardDescription>
+            {formatFromCopy(copy, 'install.restore.doneDetail', {
+              bundle: outcome.bundle,
+              version: outcome.version,
+              posts: outcome.posts,
+            })}
+          </CardDescription>
+        </CardHeader>
+        <CardContent className="flex flex-col gap-3 text-sm">
+          {outcome.migrationsApplied > 0 && (
+            <p>
+              {formatFromCopy(copy, 'install.restore.migrated', {
+                count: outcome.migrationsApplied,
+              })}
+            </p>
+          )}
+          {outcome.uploads === 'none' && <p>{fromCopy(copy, 'install.restore.noUploads')}</p>}
+          {outcome.skippedKeys > 0 && (
+            <p className="text-destructive">
+              {formatFromCopy(copy, 'install.restore.skipped', { count: outcome.skippedKeys })}
+            </p>
+          )}
+          <p>{fromCopy(copy, 'install.restore.next')}</p>
+          <p>
+            <a href="/login" className="underline">
+              {fromCopy(copy, 'install.restore.signIn')}
+            </a>
+          </p>
+        </CardContent>
+      </Card>
+    )
+  }
+
+  return (
+    <Card aria-labelledby="install-restore">
+      <CardHeader>
+        <CardTitle id="install-restore">{fromCopy(copy, 'install.restore.title')}</CardTitle>
+        <CardDescription>{fromCopy(copy, 'install.restore.hint')}</CardDescription>
+      </CardHeader>
+      <CardContent className="flex flex-col gap-4">
+        {problem !== null && (
+          <Alert tone="warning">
+            <AlertDescription>{problem}</AlertDescription>
+          </Alert>
+        )}
+        {candidates.length === 0 ? (
+          <p className="text-sm text-muted-foreground">
+            {destination === null
+              ? fromCopy(copy, 'install.restore.noneLocal')
+              : formatFromCopy(copy, 'install.restore.noneAnywhere', { destination })}
+          </p>
+        ) : (
+          <form action={submit} className="flex flex-col gap-4">
+            {state.error !== undefined && (
+              <Alert tone="error" ref={errorRef} tabIndex={-1}>
+                <AlertDescription>
+                  <AlertTitle>{fromCopy(copy, 'install.restore.notRestored')}</AlertTitle>{' '}
+                  {state.error}
+                </AlertDescription>
+              </Alert>
+            )}
+            <fieldset className="flex flex-col gap-2">
+              <legend className="text-sm font-medium">
+                {fromCopy(copy, 'install.restore.pick')}
+              </legend>
+              {candidates.map((candidate, index) => (
+                <label key={candidate.name} className="flex items-start gap-2 text-sm">
+                  <input
+                    type="radio"
+                    name="bundle"
+                    value={candidate.name}
+                    defaultChecked={index === 0}
+                    className="mt-1 size-4"
+                  />
+                  <span className="flex min-w-0 flex-col">
+                    <span className="font-medium">{candidate.label}</span>
+                    <span className="truncate text-xs text-muted-foreground">
+                      <code>{candidate.name}</code> · {candidate.size} · {candidate.location}
+                    </span>
+                  </span>
+                </label>
+              ))}
+            </fieldset>
+            <label className="flex items-start gap-2 text-sm">
+              <input type="checkbox" name="confirm" value="1" className="mt-1 size-4" />
+              <span>{fromCopy(copy, 'install.restore.confirm')}</span>
+            </label>
+            <div className="flex flex-wrap items-center gap-3">
+              <Button type="submit" variant="secondary" size="lg" disabled={pending}>
+                {pending
+                  ? fromCopy(copy, 'install.restore.restoring')
+                  : fromCopy(copy, 'install.restore.submit')}
+              </Button>
+              <p className="text-xs text-muted-foreground">
+                {pending
+                  ? fromCopy(copy, 'install.restore.pendingNote')
+                  : fromCopy(copy, 'install.restore.idleNote')}
+              </p>
+            </div>
+          </form>
+        )}
+      </CardContent>
+    </Card>
+  )
+}

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

@@ -0,0 +1,115 @@
+'use server'
+
+import { rm } from 'node:fs/promises'
+
+import { revalidatePath } from 'next/cache'
+
+import { isBundleName } from '@meith/backup'
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+import { recordAdminAction, requireAdmin, requireFreshAdmin } from './admin'
+import type { FormState } from './auth-form-state'
+import {
+  backupsAvailable,
+  currentBackupSettings,
+  destinationFor,
+  localBundlePath,
+  requireBackupRuns,
+} from './backup-admin'
+import { requireConfirmation } from './confirm'
+import { formStateReporter } from './form-state-reporter'
+import { tr } from './i18n'
+
+const toFormState = formStateReporter('backup-admin', 'backup action failed')
+
+const BACKUPS_PATH = '/admin/system/backups'
+
+function refreshBackupsScreen(): void {
+  revalidatePath(BACKUPS_PATH)
+}
+
+export async function requestBackupAction(): Promise<FormState> {
+  try {
+    const admin = await requireAdmin()
+    if (backupsAvailable() !== 'available') {
+      throw new ValidationError(msg('error.app.backups-not-on-this-deployment'))
+    }
+
+    const { queued } = await requireBackupRuns().enqueue({
+      trigger: 'manual',
+      requestedByUserId: admin.session.userId,
+      now: new Date(),
+    })
+
+    refreshBackupsScreen()
+    if (queued) await recordAdminAction({ action: 'backup.requested' })
+    return { notice: queued ? 'queued' : 'already' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+function bundleNameFrom(form: FormData): string {
+  const raw = form.get('name')
+  const name = typeof raw === 'string' ? raw.trim() : ''
+  if (!isBundleName(name)) throw new ValidationError(msg('error.app.not-a-backup-bundle-name'))
+  return name
+}
+
+export async function deleteBackupAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireFreshAdmin()
+    const name = bundleNameFrom(form)
+
+    const confirm = requireConfirmation(form, await tr('adminBackups.confirm.delete'))
+    if (confirm !== null) return confirm
+
+    const local = await localBundlePath(name)
+    if (local !== null) await rm(local, { force: true })
+
+    let remote = false
+    const destination = destinationFor(await currentBackupSettings())
+    if (destination !== undefined) {
+      const listed = await destination.list()
+      if (listed.some((bundle) => bundle.name === name)) {
+        await destination.delete(name)
+        remote = true
+      }
+    }
+
+    if (local === null && !remote) throw new ValidationError(msg('error.app.no-such-bundle'))
+
+    refreshBackupsScreen()
+    await recordAdminAction({
+      action: 'backup.deleted',
+      detail: { name, local: local !== null, remote },
+    })
+    return { notice: 'deleted', values: { name } }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function testBackupDestinationAction(): Promise<FormState> {
+  try {
+    await requireAdmin()
+    const settings = await currentBackupSettings()
+    if (settings.destination.problem !== null) {
+      throw new ValidationError(settings.destination.problem)
+    }
+    const destination = destinationFor(settings)
+    if (destination === undefined) {
+      throw new ValidationError(msg('error.app.no-off-site-destination'))
+    }
+
+    const bundles = await destination.list()
+    await recordAdminAction({
+      action: 'backup.destination_tested',
+      detail: { count: bundles.length },
+    })
+    return { notice: 'reachable', values: { count: String(bundles.length) } }
+  } catch (err) {
+    return toFormState(err)
+  }
+}

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),
+      }),
+    }
+  }
+}