@meith/web 0.33.4 → 0.34.0

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.4'
+export const CODE_VERSION = '0.34.0'
 
 export interface UpgradeApplied {
   readonly plugins: readonly string[]

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/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',
 ]