@meith/web 0.16.0

package/src/server/error-notice.tsx

@@ -0,0 +1,41 @@
+import 'server-only'
+
+import { logger } from '@meith/core'
+import { currentRequestId } from '@meith/core/logger'
+import { requireSlot, slotCopy } from '@meith/theme-kit'
+
+import { getTranslator } from '@/server/i18n'
+import { buildErrorNotice, CRASH_NOTICE, type ErrorNoticeCopy } from '@/view/error-notice'
+
+import { filterView } from './plugin-view'
+import { currentTheme } from './theme'
+
+export async function renderErrorNotice(copy: ErrorNoticeCopy): Promise<React.ReactNode> {
+  const requestId = currentRequestId() ?? null
+  const ErrorNotice = requireSlot(await currentTheme(), 'ErrorNotice')
+  const translator = await getTranslator()
+
+  const model = await filterView(
+    'view.error-notice',
+    buildErrorNotice(copy, requestId, translator),
+    {
+      userId: null,
+      isGuest: true,
+      requestId,
+    },
+  )
+
+  return <ErrorNotice {...model} copy={slotCopy(await currentTheme(), 'ErrorNotice', translator)} />
+}
+
+export async function crashNotice(): Promise<React.ReactNode> {
+  try {
+    return await renderErrorNotice(CRASH_NOTICE)
+  } catch (error) {
+    logger({ module: 'error-notice' }).warn(
+      { err: String(error) },
+      'could not resolve the themed crash notice',
+    )
+    return null
+  }
+}

package/src/server/federation-actions.ts

@@ -0,0 +1,113 @@
+'use server'
+
+import { redirect } from 'next/navigation'
+
+import { ForbiddenError } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+import { recordAuthEvent } from './auth-events'
+import type { FormState } from './auth-form-state'
+import { getContainer } from './container'
+import { getActor } from './context'
+import { assertDemoAccountChangeable } from './demo'
+import {
+  federationService,
+  memberManagedSignIns,
+  passkeyService,
+  passkeysEnabled,
+  signInProviders,
+} from './federation'
+import { formStateReporter } from './form-state-reporter'
+import { text } from './form-values'
+import { tr } from './i18n'
+
+const toFormState = formStateReporter(
+  'federation-actions',
+  'unexpected error while changing a sign-in',
+)
+
+/**
+ * Only a credential the board would actually accept today counts as a way back
+ * in. A passkey on a board that has since switched passkeys off, or a link to a
+ * provider an operator has turned off, opens nothing — counting it would let a
+ * member unlink their way out of their own account in one click.
+ */
+async function usableWaysIn(userId: number): Promise<{
+  readonly usablePasskeys: number
+  readonly usableProviders: readonly string[]
+}> {
+  const providers = await signInProviders()
+  const passkeys = (await passkeysEnabled())
+    ? (await getContainer().accountStore.passkeys.listForUser(userId)).length
+    : 0
+
+  return {
+    usablePasskeys: passkeys,
+    usableProviders: providers.map((provider) => provider.id),
+  }
+}
+
+async function requireOwnAccount(): Promise<{
+  readonly userId: number
+  readonly hasPassword: boolean
+}> {
+  const actor = await getActor()
+  if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+
+  if (!(await memberManagedSignIns())) {
+    throw new ForbiddenError(msg('error.app.board-manages-sign-ins-for-its'))
+  }
+
+  await assertDemoAccountChangeable(actor.userId, 'password')
+
+  const account = await getContainer().accountStore.accounts.findById(actor.userId)
+  if (account === null) throw new ForbiddenError(msg('error.app.account-longer-exists'))
+
+  return { userId: actor.userId, hasPassword: account.passwordHash !== null }
+}
+
+export async function unlinkIdentityAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    const { userId, hasPassword } = await requireOwnAccount()
+    const identityId = Number(text(form, 'identityId'))
+    if (!Number.isInteger(identityId)) {
+      return { error: await tr('notice.app.sign-in-could-found') }
+    }
+
+    await (await federationService()).unlink({
+      userId,
+      identityId,
+      hasPassword,
+      ...(await usableWaysIn(userId)),
+    })
+
+    await recordAuthEvent({ userId, kind: 'identity_unlinked' })
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/usercp/security?sso=unlinked')
+}
+
+export async function removePasskeyAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    const { userId, hasPassword } = await requireOwnAccount()
+    const passkeyId = Number(text(form, 'passkeyId'))
+    if (!Number.isInteger(passkeyId)) {
+      return { error: await tr('notice.app.passkey-could-found') }
+    }
+
+    await (await passkeyService()).remove({
+      userId,
+      passkeyId,
+      hasPassword,
+      usableProviders: (await usableWaysIn(userId)).usableProviders,
+    })
+
+    await recordAuthEvent({ userId, kind: 'passkey_removed' })
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/usercp/security?passkey=removed')
+}

package/src/server/federation.ts

@@ -0,0 +1,138 @@
+import 'server-only'
+
+import { headers } from 'next/headers'
+
+import {
+  configuredProviders,
+  type FederationOptions,
+  FederationService,
+  type IdentityProvider,
+  isProviderKind,
+  PasskeyService,
+  type ProviderKind,
+  providerFor,
+  type RelyingParty,
+} from '@meith/accounts'
+import { env } from '@meith/core'
+import type { SettingsSnapshot } from '@meith/settings'
+
+import { boardUrl } from './board-url'
+import { configuredIdentity, getContainer } from './container'
+import { getSettings, getSettingsUncached } from './settings'
+
+export const SSO_CALLBACK_PREFIX = '/auth/sso'
+
+export interface ProviderButton {
+  readonly id: ProviderKind
+  readonly label: string
+}
+
+export function federationOptions(settings: SettingsSnapshot): FederationOptions {
+  return {
+    github: {
+      enabled: settings.get('federation.github_enabled'),
+      clientId: settings.get('federation.github_client_id'),
+      clientSecret: settings.get('federation.github_client_secret'),
+    },
+    google: {
+      enabled: settings.get('federation.google_enabled'),
+      clientId: settings.get('federation.google_client_id'),
+      clientSecret: settings.get('federation.google_client_secret'),
+    },
+    oidc: {
+      enabled: settings.get('federation.oidc_enabled'),
+      clientId: settings.get('federation.oidc_client_id'),
+      clientSecret: settings.get('federation.oidc_client_secret'),
+      issuer: settings.get('federation.oidc_issuer'),
+      label: settings.get('federation.oidc_label'),
+      scopes: settings.get('federation.oidc_scopes'),
+    },
+  }
+}
+
+/**
+ * Every read here goes past the settings cache, because every one of them
+ * decides whether a sign-in may start rather than what a page displays. The
+ * cached snapshot is held per module instance, so a route handler can be a
+ * minute behind the render that invalidated it — long enough for a provider an
+ * operator has just switched on to answer that it is switched off.
+ */
+export async function federationProvider(id: string): Promise<IdentityProvider | null> {
+  if (!isProviderKind(id)) return null
+  if (getContainer().dataSource !== 'postgres') return null
+
+  return providerFor(id, federationOptions(await getSettingsUncached()))
+}
+
+export async function signInProviders(): Promise<readonly ProviderButton[]> {
+  if (getContainer().dataSource !== 'postgres') return []
+
+  return configuredProviders(federationOptions(await getSettingsUncached())).map((provider) => ({
+    id: provider.id,
+    label: provider.label,
+  }))
+}
+
+export async function passkeysEnabled(): Promise<boolean> {
+  if (getContainer().dataSource !== 'postgres') return false
+  return (await getSettingsUncached()).get('federation.passkeys_enabled')
+}
+
+export async function memberManagedSignIns(): Promise<boolean> {
+  return (await getSettingsUncached()).get('federation.link_from_usercp')
+}
+
+export async function federationService(): Promise<FederationService> {
+  const { accountStore } = getContainer()
+
+  return new FederationService({
+    identity: await configuredIdentity(),
+    accounts: accountStore.accounts,
+    identities: accountStore.identities,
+  })
+}
+
+export async function passkeyService(): Promise<PasskeyService> {
+  const { accountStore } = getContainer()
+
+  return new PasskeyService({
+    identity: await configuredIdentity(),
+    accounts: accountStore.accounts,
+    passkeys: accountStore.passkeys,
+    identities: accountStore.identities,
+  })
+}
+
+export function callbackPath(provider: ProviderKind): string {
+  return `${SSO_CALLBACK_PREFIX}/${provider}/callback`
+}
+
+export async function callbackUrl(provider: ProviderKind): Promise<string> {
+  return new URL(callbackPath(provider), await requestOrigin()).toString()
+}
+
+export async function relyingParty(): Promise<RelyingParty> {
+  const origin = await requestOrigin()
+  return { id: new URL(origin).hostname, origin }
+}
+
+export async function passkeyRelyingPartyName(): Promise<string> {
+  const name = (await getSettings()).get('board.name')
+  return name.trim() === '' ? 'this board' : name
+}
+
+async function requestOrigin(): Promise<string> {
+  const configured = await boardUrl()
+  if (configured !== '') return configured
+
+  const incoming = await headers()
+  const host = incoming.get('x-forwarded-host') ?? incoming.get('host')
+  if (host === null || host.trim() === '') {
+    throw new Error('the board has no address to send an identity provider back to')
+  }
+
+  const scheme =
+    incoming.get('x-forwarded-proto') ?? (env.NODE_ENV === 'development' ? 'http' : 'https')
+
+  return `${scheme.split(',')[0]!.trim()}://${host.trim()}`
+}

package/src/server/feed-builder.ts

@@ -0,0 +1,72 @@
+import 'server-only'
+
+import type { FeedPost, FeedThread } from '@meith/db'
+import type { CompiledWordFilter } from '@meith/markdown'
+
+import { type FeedChannel, type FeedEntry, summarise } from '@/view/feed'
+import { postLink } from '@/view/post-link'
+import { filterWords } from '@/view/word-filter'
+
+import { absoluteTo } from './syndication'
+
+export function feedFor(
+  origin: string,
+  wordFilter: CompiledWordFilter | undefined,
+): {
+  threadEntry: (thread: FeedThread) => FeedEntry
+  postEntry: (post: FeedPost) => FeedEntry
+  channel: (input: ChannelInput) => FeedChannel
+} {
+  const absolute = (path: string): string => absoluteTo(origin, path)
+
+  const tagId = (kind: 'thread' | 'post', id: number): string => {
+    const host = origin.replace(/^https?:\/\//, '')
+    return `tag:${host},2026:${kind}/${id}`
+  }
+
+  function threadEntry(thread: FeedThread): FeedEntry {
+    return {
+      id: tagId('thread', thread.threadId),
+      title: thread.title,
+      href: absolute(`/thread/${thread.threadId}-${thread.slug}`),
+      author: thread.authorUsername,
+      published: thread.createdAt,
+      updated: thread.lastPostAt,
+      summary: filterWords(summarise(thread.excerptSource), wordFilter),
+    }
+  }
+
+  function postEntry(post: FeedPost): FeedEntry {
+    return {
+      id: tagId('post', post.postId),
+      title: post.threadTitle,
+      href: absolute(postLink(`/thread/${post.threadId}-${post.threadSlug}`, post.postId)),
+      author: post.authorUsername,
+      published: post.createdAt,
+      updated: post.createdAt,
+      summary: filterWords(summarise(post.messageSource), wordFilter),
+    }
+  }
+
+  function channel(input: ChannelInput): FeedChannel {
+    return {
+      title: input.title,
+      description: input.description,
+      href: absolute(input.path),
+      selfHref: absolute(input.selfPath),
+      updated: input.entries[0]?.updated ?? input.now,
+      entries: input.entries,
+    }
+  }
+
+  return { threadEntry, postEntry, channel }
+}
+
+interface ChannelInput {
+  readonly title: string
+  readonly description: string
+  readonly path: string
+  readonly selfPath: string
+  readonly entries: readonly FeedEntry[]
+  readonly now: Date
+}

package/src/server/feed-routes.ts

@@ -0,0 +1,122 @@
+import 'server-only'
+
+import { type FeedChannel, type FeedEntry, renderAtom, renderRss } from '@/view/feed'
+
+import { boardOffline } from './board-offline'
+import { activeWordFilter } from './content-admin'
+import { feedFor } from './feed-builder'
+import { filterView } from './plugin-view'
+import { getSettings } from './settings'
+import { FEED_LIMIT, feedRepository, origin, publicScope } from './syndication'
+
+const CACHE = 'public, max-age=300, stale-while-revalidate=3600'
+
+export type FeedFormat = 'rss' | 'atom'
+
+export type FeedScope = 'board' | 'forum' | 'thread'
+
+/**
+ * A plugin may reorder, drop, or add. An entry it adds keeps the board's own
+ * fields where one matches by href, and is otherwise taken as given — a feed
+ * is rendered as a guest, so everything in it is already public.
+ */
+async function filterEntries(
+  entries: readonly FeedEntry[],
+  feed: FeedScope,
+): Promise<readonly FeedEntry[]> {
+  const filtered = await filterView(
+    'feed.items',
+    entries.map((entry) => ({
+      title: entry.title,
+      href: entry.href,
+      publishedAt: entry.published.toISOString(),
+      summary: entry.summary,
+    })),
+    { feed },
+  )
+
+  const byHref = new Map(entries.map((entry) => [entry.href, entry]))
+  return filtered.map((row) => {
+    const original = byHref.get(row.href)
+    const published = new Date(row.publishedAt)
+    return {
+      id: original?.id ?? row.href,
+      title: row.title,
+      href: row.href,
+      author: original?.author ?? '',
+      published: Number.isNaN(published.getTime())
+        ? (original?.published ?? new Date())
+        : published,
+      updated: original?.updated ?? published,
+      summary: row.summary,
+    }
+  })
+}
+
+export async function feedResponse(
+  channel: FeedChannel,
+  format: FeedFormat,
+  feed: FeedScope,
+): Promise<Response> {
+  const withEntries = { ...channel, entries: await filterEntries(channel.entries, feed) }
+  const body = format === 'atom' ? renderAtom(withEntries) : renderRss(withEntries)
+  return new Response(body, {
+    headers: {
+      'content-type':
+        format === 'atom'
+          ? 'application/atom+xml; charset=utf-8'
+          : 'application/rss+xml; charset=utf-8',
+      'cache-control': CACHE,
+    },
+  })
+}
+
+export function xmlResponse(body: string): Response {
+  return new Response(body, {
+    headers: { 'content-type': 'application/xml; charset=utf-8', 'cache-control': CACHE },
+  })
+}
+
+export async function offlineFeed(): Promise<Response | null> {
+  const offline = await boardOffline()
+  if (offline === null) return null
+
+  return new Response(offline.message, {
+    status: 503,
+    headers: { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' },
+  })
+}
+
+export async function boardFeed(format: FeedFormat, selfPath: string): Promise<Response> {
+  const offline = await offlineFeed()
+  if (offline !== null) return offline
+
+  const repo = feedRepository()
+  if (repo === null) return noFeed()
+
+  const scope = await publicScope()
+  const threads = await repo.recentThreads(FEED_LIMIT, scope)
+  const settings = await getSettings()
+
+  const feed = feedFor(await origin(), await activeWordFilter())
+
+  return feedResponse(
+    feed.channel({
+      title: settings.get('board.name'),
+      description: settings.get('board.description'),
+      path: '/',
+      selfPath,
+      entries: threads.map(feed.threadEntry),
+      now: new Date(),
+    }),
+    format,
+    'board',
+  )
+}
+
+export function noFeed(): Response {
+  return new Response('Not found', {
+    status: 404,
+    headers: { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' },
+  })
+}

package/src/server/fixture-actor-source.ts

@@ -0,0 +1,62 @@
+import 'server-only'
+
+import type { AccountStore } from '@meith/accounts'
+import {
+  type Actor,
+  type ActorSource,
+  type ActorState,
+  combinePermissionSets,
+  type GroupDefaults,
+} from '@meith/authorization'
+import { emptyPermissionSet } from '@meith/core'
+
+import { SEED_BOARD, SEED_GROUP } from './seed-board'
+
+function mapState(state: 'active' | 'awaiting_activation' | 'banned'): ActorState {
+  return state
+}
+
+export class FixtureActorSource implements ActorSource {
+  private readonly groupsById: Map<number, GroupDefaults>
+
+  constructor(private readonly store: AccountStore) {
+    this.groupsById = new Map(SEED_BOARD.groups.map((g) => [g.groupId, g]))
+  }
+
+  async buildGuest(): Promise<Actor> {
+    const groupIds = [SEED_GROUP.guest]
+    return {
+      userId: null,
+      groupIds,
+      primaryGroupId: SEED_GROUP.guest,
+      state: 'guest',
+      global: this.combine(groupIds),
+      permissionVersion: 1,
+    }
+  }
+
+  async buildForUser(userId: number): Promise<Actor | null> {
+    const account = await this.store.accounts.findById(userId)
+    if (!account) return null
+
+    const primaryGroupId = account.primaryGroupId ?? SEED_GROUP.registered
+    const groupIds = [primaryGroupId]
+
+    return {
+      userId: account.id,
+      groupIds,
+      primaryGroupId,
+      state: mapState(account.state),
+      global: this.combine(groupIds),
+      permissionVersion: 1,
+    }
+  }
+
+  private combine(groupIds: readonly number[]) {
+    const sets = groupIds
+      .map((id) => this.groupsById.get(id)?.permissions)
+      .filter((p): p is NonNullable<typeof p> => p !== undefined)
+    if (sets.length === 0) return emptyPermissionSet()
+    return combinePermissionSets(sets)
+  }
+}

package/src/server/fixture-forum-repo.ts

@@ -0,0 +1,59 @@
+import 'server-only'
+
+import { ConfigurationError } from '@meith/core'
+import type {
+  ForumListingRow,
+  ForumRepository,
+  ForumRow,
+  MovePlan,
+  MoveTarget,
+  NewForum,
+} from '@meith/forums'
+
+import { SEED_FORUM_ROWS } from './seed-board'
+
+function structural(row: ForumListingRow): ForumRow {
+  const { threadCount: _t, postCount: _p, lastPost: _l, ...rest } = row
+  return rest
+}
+
+function unsupported(operation: string): never {
+  throw new ConfigurationError(
+    `Cannot ${operation} in fixture mode: the board is in-memory sample data and ` +
+      'any change is lost when the process exits. Set DATABASE_URL and ' +
+      'DATA_SOURCE=postgres to manage a real board.',
+  )
+}
+
+export class FixtureForumRepository implements ForumRepository {
+  constructor(private readonly rows: readonly ForumListingRow[] = SEED_FORUM_ROWS) {}
+
+  async listAll(): Promise<ForumRow[]> {
+    return this.ordered().map(structural)
+  }
+
+  async listListing(): Promise<ForumListingRow[]> {
+    return this.ordered().map((row) => ({ ...row }))
+  }
+
+  async findById(id: number): Promise<ForumRow | null> {
+    const row = this.rows.find((r) => r.id === id)
+    return row ? structural(row) : null
+  }
+
+  private ordered(): ForumListingRow[] {
+    return [...this.rows].sort((a, b) => a.displayOrder - b.displayOrder || a.id - b.id)
+  }
+
+  async create(_input: NewForum): Promise<ForumRow> {
+    unsupported('create a forum')
+  }
+
+  async move(_forumId: number, _target: MoveTarget): Promise<void> {
+    unsupported('move a forum')
+  }
+
+  async applyMove(_plan: MovePlan): Promise<void> {
+    unsupported('move a forum')
+  }
+}

package/src/server/fixture-member-profile-repo.ts

@@ -0,0 +1,30 @@
+import 'server-only'
+
+import type {
+  MemberProfileRecord,
+  MemberProfileRepository,
+  MemberSuggestion,
+} from '@meith/accounts'
+
+import { SEED_MEMBER_PROFILES } from './seed-board'
+
+export class FixtureMemberProfileRepository implements MemberProfileRepository {
+  constructor(private readonly rows: readonly MemberProfileRecord[] = SEED_MEMBER_PROFILES) {}
+
+  async findPublicById(id: number): Promise<MemberProfileRecord | null> {
+    return this.rows.find((row) => row.id === id) ?? null
+  }
+
+  async searchByUsernamePrefix(
+    prefix: string,
+    limit: number,
+  ): Promise<readonly MemberSuggestion[]> {
+    if (prefix === '') return []
+    const lower = prefix.toLowerCase()
+    return this.rows
+      .filter((row) => row.username.toLowerCase().startsWith(lower))
+      .sort((a, b) => a.username.localeCompare(b.username))
+      .slice(0, limit)
+      .map((row) => ({ id: row.id, username: row.username }))
+  }
+}