@meith/web 0.16.0

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

@@ -0,0 +1,134 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+
+import { NotFoundError, ValidationError } from '@meith/core'
+import { drivers } from '@meith/drivers'
+import { msg } from '@meith/i18n'
+
+import { recordAdminAction, requireAdmin } from './admin'
+import type { FormState } from './auth-form-state'
+import { clearableTag } from './cache-targets'
+import { formStateReporter } from './form-state-reporter'
+import { requireSearch } from './search'
+import { requireMaintenance, requireRecount } from './system-admin'
+
+const SWEEP_LIMIT = 5_000
+
+const RECOUNT_BATCH = 500
+
+const REINDEX_BATCH = 2_000
+
+const toFormState = formStateReporter('system-admin', 'maintenance action failed')
+
+function refreshSystemScreen(): void {
+  revalidatePath('/admin/system')
+}
+
+export async function pruneSessionsAction(): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const removed = await requireMaintenance().pruneSessions(new Date(), SWEEP_LIMIT)
+
+    refreshSystemScreen()
+    await recordAdminAction({ action: 'system.sessions_pruned', detail: { removed } })
+    return { notice: 'pruned', values: { removed: String(removed) } }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function pruneTokensAction(): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const removed = await requireMaintenance().pruneExpiredTokens(new Date(), SWEEP_LIMIT)
+
+    refreshSystemScreen()
+    await recordAdminAction({ action: 'system.tokens_pruned', detail: { removed } })
+    return { notice: 'pruned', values: { removed: String(removed) } }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function recountAction(): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const { corrected } = await requireRecount().run(RECOUNT_BATCH)
+
+    refreshSystemScreen()
+    await recordAdminAction({ action: 'system.recount_ran', detail: { corrected } })
+    return { notice: 'ran', values: { corrected: String(corrected) } }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function reindexSearchAction(): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const result = await requireSearch().reindexChunk(0, REINDEX_BATCH)
+    const progress = await requireSearch().indexProgress()
+
+    refreshSystemScreen()
+    await recordAdminAction({
+      action: 'system.search_reindexed',
+      detail: { indexed: result.indexed, pending: progress.pending },
+    })
+
+    return {
+      notice: progress.pending > 0 ? 'more' : 'finished',
+      values: { indexed: String(result.indexed), pending: String(progress.pending) },
+    }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function clearCacheAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const tag = clearableTag(form.get('what'))
+
+    if (tag === null) throw new ValidationError(msg('error.app.choose-what-clear'))
+
+    await drivers().cache.invalidateTags([tag])
+
+    refreshSystemScreen()
+    await recordAdminAction({ action: 'system.cache_cleared', detail: { tag } })
+    return { notice: 'cleared', values: { tag } }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function retryJobAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const jobId = form.get('jobId')
+    if (typeof jobId !== 'string' || jobId.trim() === '') {
+      throw new ValidationError(msg('error.app.such-job'))
+    }
+
+    const id = jobId.trim()
+    const requeued = await drivers().queue.retry(id)
+
+    if (!requeued) {
+      throw new NotFoundError(
+        `No dead-lettered job ${id}. Only a job that has exhausted its attempts can be retried.`,
+      )
+    }
+
+    refreshSystemScreen()
+    await recordAdminAction({ action: 'system.job_retried', detail: { jobId: id } })
+    return { notice: 'retried' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}

package/src/server/system-admin.ts

@@ -0,0 +1,90 @@
+import { msg } from '@meith/i18n'
+import 'server-only'
+
+import { ForbiddenError } from '@meith/core'
+import {
+  type BoardVolumes,
+  getDb,
+  PostgresCounterRecount,
+  PostgresMaintenanceRepository,
+  PostgresSearchRepository,
+  PostgresSystemHealthRepository,
+  type RecountStateRow,
+  type TaskRunRow,
+} from '@meith/db'
+import { assessScheduler, type SchedulerHealth, type TaskHealth } from '@meith/tasks'
+
+import { getContainer } from './container'
+import { assessMailReadiness, type MailReadiness } from './mail-health'
+
+export function systemHealthRepository(): PostgresSystemHealthRepository | null {
+  return getContainer().dataSource === 'postgres'
+    ? new PostgresSystemHealthRepository(getDb())
+    : null
+}
+
+export function requireMaintenance(): PostgresMaintenanceRepository {
+  if (getContainer().dataSource !== 'postgres') {
+    throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-6'))
+  }
+  return new PostgresMaintenanceRepository(getDb())
+}
+
+export function requireRecount(): PostgresCounterRecount {
+  if (getContainer().dataSource !== 'postgres') {
+    throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-7'))
+  }
+  return new PostgresCounterRecount(getDb())
+}
+
+export interface SystemHealthView {
+  readonly searchIndex: { readonly indexed: number; readonly pending: number }
+  readonly scheduler: Omit<SchedulerHealth, 'tasks'> & {
+    readonly tasks: readonly (TaskHealth & {
+      readonly titleKey?: string
+      readonly descriptionKey?: string
+    })[]
+  }
+  readonly mail: MailReadiness
+  readonly runs: readonly TaskRunRow[]
+  readonly recount: readonly RecountStateRow[]
+  readonly volumes: BoardVolumes
+  readonly prunableSessions: number
+}
+
+export async function buildSystemHealthView(now: Date): Promise<SystemHealthView | null> {
+  const repository = systemHealthRepository()
+  if (repository === null) return null
+
+  const maintenance = new PostgresMaintenanceRepository(getDb())
+  const [tasks, runs, recount, volumes, prunableSessions, searchIndex, mail] = await Promise.all([
+    repository.taskHealth(),
+    repository.recentRuns(20),
+    repository.recountState(),
+    repository.volumes(),
+    maintenance.countPrunableSessions(now),
+    new PostgresSearchRepository(getDb()).indexProgress(),
+    assessMailReadiness(),
+  ])
+
+  const scheduler = assessScheduler(tasks, now)
+  const taskMessages = new Map(
+    (getContainer().scheduler?.tasks ?? []).map((task) => [
+      task.id,
+      { titleKey: task.titleKey, descriptionKey: task.descriptionKey },
+    ]),
+  )
+
+  return {
+    scheduler: {
+      ...scheduler,
+      tasks: scheduler.tasks.map((task) => ({ ...task, ...taskMessages.get(task.key) })),
+    },
+    searchIndex,
+    mail,
+    runs,
+    recount,
+    volumes,
+    prunableSessions,
+  }
+}

package/src/server/test-container.ts

@@ -0,0 +1,114 @@
+import { createMemoryStore, IdentityService, SessionService } from '@meith/accounts'
+import type { MemoryAppointment, MemoryBoard } from '@meith/authorization'
+import { Authorizer, InMemoryAuthorizationSource } from '@meith/authorization'
+
+import { ABSENT_SERVICES } from './absent-services'
+import { FixtureActorSource } from './fixture-actor-source'
+import { FIXTURE_DATA_VERSION, SEED_BOARD } from './seed-board'
+
+export const CONTAINER_KEY = Symbol.for('@meith/forum.container')
+
+export type TestContainerOverrides = Record<string, unknown>
+
+export interface TestContainerOptions {
+  readonly moderators?: readonly MemoryAppointment[]
+  readonly overrides?: MemoryBoard['overrides']
+  readonly board?: MemoryBoard
+  readonly container?: TestContainerOverrides
+}
+
+export function installTestContainer(options: TestContainerOptions = {}): Record<string, unknown> {
+  const store = createMemoryStore()
+  const board: MemoryBoard = options.board ?? {
+    ...SEED_BOARD,
+    moderators: options.moderators ?? [],
+    overrides: [...SEED_BOARD.overrides, ...(options.overrides ?? [])],
+  }
+
+  const container = {
+    authorizer: new Authorizer(new InMemoryAuthorizationSource(board), {}),
+
+    ...ABSENT_SERVICES,
+    ...identityOver(store),
+
+    threads: {
+      locate: async () => null,
+      findById: async () => null,
+      listForum: async () => ({ rows: [], nextCursor: null }),
+    },
+    posts: {
+      findRatingTarget: async () => null,
+      findVisibleById: async () => null,
+      listThread: async () => ({ rows: [], nextAfterId: null }),
+    },
+    memberProfiles: { findPublicById: async () => null },
+    forums: {
+      listAll: async () => [],
+      listListing: async () => [],
+      findById: async () => null,
+    },
+
+    fixtureDataVersion: FIXTURE_DATA_VERSION,
+    dataSource: 'fixture' as const,
+
+    ...options.container,
+  }
+
+  ;(globalThis as Record<symbol, unknown>)[CONTAINER_KEY] = container
+  return container
+}
+
+function identityOver(store: ReturnType<typeof createMemoryStore>) {
+  return {
+    accountStore: store,
+    actorSource: new FixtureActorSource(store),
+    identity: new IdentityService({
+      store,
+      config: {
+        registrationEnabled: true,
+        minPasswordLength: 8,
+        usernameMin: 3,
+        usernameMax: 30,
+        activationMethod: 'none',
+        maxLoginAttempts: 5,
+        maxAccountLoginAttempts: 50,
+        lockoutMinutes: 15,
+        sessionLifetimeDays: 30,
+        resetTokenTtlMinutes: 60,
+        reservedUsernames: [],
+        defaultMemberGroupId: 2,
+      },
+    }),
+    sessions: new SessionService({
+      store,
+      rememberDays: 30,
+      sessionLifetimeDays: 30,
+    }),
+  }
+}
+
+export function clearTestContainer(): void {
+  delete (globalThis as Record<symbol, unknown>)[CONTAINER_KEY]
+}
+
+export function appointment(
+  forumId: number,
+  rights: Partial<MemoryAppointment> = {},
+  userId = 3,
+): MemoryAppointment {
+  return {
+    userId,
+    forumId,
+    cascadeToSubforums: false,
+    canApproveContent: false,
+    canEditPosts: false,
+    canSoftDeletePosts: false,
+    canRestorePosts: false,
+    canOpenCloseThreads: false,
+    canStickThreads: false,
+    canMoveThreads: false,
+    canMergeThreads: false,
+    canSplitThreads: false,
+    ...rights,
+  }
+}

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

@@ -0,0 +1,242 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+
+import { CacheTags, isAppError, ValidationError } from '@meith/core'
+import { parseThemeExport } from '@meith/db'
+import { drivers } from '@meith/drivers'
+import { msg } from '@meith/i18n'
+
+import { recordAdminAction, requireAdmin, requireFreshAdmin } from './admin'
+import type { FormState } from './auth-form-state'
+import { formStateReporter } from './form-state-reporter'
+import { trimmedText } from './form-values'
+import {
+  isBuildTheme,
+  requireThemeAdmin,
+  themeListing,
+  themeTitle,
+  themeTokens,
+} from './theme-admin'
+import { validateCustomCss, validateTokenOverrides } from './theme-style'
+
+const reportFailure = formStateReporter('theme-admin', 'theme write failed')
+
+async function toFormState(err: unknown): Promise<FormState> {
+  if (!isAppError(err) && err instanceof Error && err.message.startsWith('Theme ')) {
+    return { error: err.message }
+  }
+  return reportFailure(err)
+}
+
+function submittedTokens(form: FormData): {
+  light: Record<string, string>
+  dark: Record<string, string>
+} {
+  const light: Record<string, string> = {}
+  const dark: Record<string, string> = {}
+
+  for (const [field, value] of form.entries()) {
+    if (typeof value !== 'string') continue
+    const match = /^token\.(light|dark|both)\.(.+)$/.exec(field)
+    if (match === null) continue
+
+    const trimmed = value.trim()
+    if (trimmed === '') continue
+
+    const [, scheme, name] = match as unknown as [string, string, string]
+    if (scheme !== 'dark') light[name] = trimmed
+    if (scheme !== 'light') dark[name] = trimmed
+  }
+
+  return { light, dark }
+}
+
+function themeKey(form: FormData): string {
+  const key = trimmedText(form, 'key')
+  if (themeTitle(key) === null) throw new ValidationError(msg('error.app.such-theme'))
+  return key
+}
+
+async function invalidateTheme(key: string): Promise<void> {
+  await drivers().cache.invalidateTags([CacheTags.theme(key)])
+  revalidatePath('/admin/themes')
+  revalidatePath('/admin/themes/[key]', 'page')
+}
+
+export async function saveThemeAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+    const key = themeKey(form)
+
+    const tokens = themeTokens(key)
+    if (tokens === null) throw new ValidationError(msg('error.app.such-theme'))
+
+    const validated = validateTokenOverrides(tokens, submittedTokens(form))
+    const customCss = trimmedText(form, 'customCss')
+    const css = validateCustomCss(customCss === '' ? null : customCss)
+
+    await requireThemeAdmin().save({
+      key,
+      title: themeTitle(key) ?? key,
+      tokenOverrides: validated,
+      customCss: css,
+    })
+
+    await invalidateTheme(key)
+    await recordAdminAction({
+      action: 'theme.saved',
+      detail: {
+        key,
+        tokens: new Set([...Object.keys(validated.light), ...Object.keys(validated.dark)]).size,
+        customCss: css !== null,
+      },
+    })
+
+    return { notice: 'saved' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function previewThemeAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+    const key = themeKey(form)
+
+    const tokens = themeTokens(key)
+    if (tokens === null) throw new ValidationError(msg('error.app.such-theme'))
+
+    const submitted: Record<string, string> = {}
+    for (const [field, value] of form.entries()) {
+      if (field.startsWith('token.') && typeof value === 'string') submitted[field] = value
+    }
+
+    const validated = validateTokenOverrides(tokens, submittedTokens(form))
+    const customCss = trimmedText(form, 'customCss')
+    const css = validateCustomCss(customCss === '' ? null : customCss)
+
+    return {
+      notice: 'previewed',
+      values: { ...submitted, customCss },
+      preview: declarationBlock(validated, css),
+    }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function themeEditorAction(prev: FormState, form: FormData): Promise<FormState> {
+  return trimmedText(form, 'intent') === 'preview'
+    ? previewThemeAction(prev, form)
+    : saveThemeAction(prev, form)
+}
+
+function declarationBlock(
+  overrides: { light: Readonly<Record<string, string>>; dark: Readonly<Record<string, string>> },
+  customCss: string | null,
+): string {
+  const declarations = (values: Readonly<Record<string, string>>): string =>
+    Object.entries(values)
+      .map(([name, value]) => `--${name}:${value};`)
+      .join('')
+
+  return (
+    `[data-theme-preview]{${declarations(overrides.light)}}` +
+    `[data-theme-preview].dark{${declarations(overrides.dark)}}` +
+    (customCss === null ? '' : `[data-theme-preview]{${customCss}}`)
+  )
+}
+
+export async function resetThemeAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireFreshAdmin()
+    const key = themeKey(form)
+
+    await requireThemeAdmin().reset(key)
+
+    await invalidateTheme(key)
+    await recordAdminAction({ action: 'theme.reset', detail: { key } })
+
+    return { notice: 'reset' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function importThemeAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireFreshAdmin()
+    const key = themeKey(form)
+
+    const tokens = themeTokens(key)
+    if (tokens === null) throw new ValidationError(msg('error.app.such-theme'))
+
+    const document = parseThemeExport(trimmedText(form, 'document'))
+    const validated = validateTokenOverrides(tokens, document.tokenOverrides)
+    const css = validateCustomCss(document.customCss)
+
+    await requireThemeAdmin().save({
+      key,
+      title: themeTitle(key) ?? key,
+      tokenOverrides: validated,
+      customCss: css,
+    })
+
+    await invalidateTheme(key)
+    await recordAdminAction({
+      action: 'theme.imported',
+      detail: {
+        key,
+        tokens: new Set([...Object.keys(validated.light), ...Object.keys(validated.dark)]).size,
+      },
+    })
+
+    return { notice: 'imported' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function setThemeEnabledAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+    const key = themeKey(form)
+    const enabled = trimmedText(form, 'enabled') === 'true'
+
+    if (!enabled) {
+      if (isBuildTheme(key)) {
+        throw new ValidationError(msg('error.app.theme-board-built-with-so'))
+      }
+      const listing = (await themeListing()).find((entry) => entry.key === key)
+      if (listing?.isDefault === true) {
+        throw new ValidationError(msg('error.app.default-theme-make-another-theme'))
+      }
+    }
+
+    await requireThemeAdmin().setEnabled(key, enabled, themeTitle(key) ?? key)
+
+    await invalidateTheme(key)
+    await recordAdminAction({ action: 'theme.enabled', detail: { key, enabled } })
+
+    return { notice: enabled ? 'enabled' : 'disabled' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}
+
+export async function setDefaultThemeAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+    const key = themeKey(form)
+
+    await requireThemeAdmin().setDefault(key, themeTitle(key) ?? key)
+
+    await invalidateTheme(key)
+    await recordAdminAction({ action: 'theme.default', detail: { key } })
+
+    return { notice: 'default' }
+  } catch (err) {
+    return toFormState(err)
+  }
+}