@meith/web 0.16.0

package/src/server/signatures.ts

@@ -0,0 +1,62 @@
+import 'server-only'
+
+import {
+  renderStoredSignature,
+  type SignatureLimits,
+  type StoredSignature,
+} from '@meith/signatures'
+
+import { getContainer } from './container'
+import { getActor } from './context'
+import { boardRendering } from './markdown-pipeline'
+import { filterView, viewerRef } from './plugin-view'
+
+export function signatureStore() {
+  return getContainer().signatures
+}
+
+export async function viewerSignatureLimits(): Promise<SignatureLimits> {
+  const actor = await getActor()
+  const { authorizer } = getContainer()
+
+  return {
+    canUse: authorizer.can(actor, 'signature.use'),
+    maxLength: authorizer.globalLimit(actor, 'maxSignatureLength'),
+  }
+}
+
+export async function renderSignature(
+  authorId: number,
+  stored: StoredSignature,
+): Promise<string | null> {
+  const html = await renderStoredSignature(stored, { authorId, rendering: boardRendering })
+  if (html === null) return null
+
+  return filterView('signature.html', html, { ...viewerRef(await getActor()), authorId })
+}
+
+export async function signaturesFor(
+  userIds: readonly number[],
+): Promise<ReadonlyMap<number, string>> {
+  const store = signatureStore()
+  if (store === null || userIds.length === 0) return new Map()
+
+  try {
+    const viewer = viewerRef(await getActor())
+    const stored = await store.readMany(userIds)
+    const out = new Map<number, string>()
+
+    for (const [userId, signature] of stored) {
+      const html = await renderStoredSignature(signature, {
+        authorId: userId,
+        rendering: boardRendering,
+      })
+      if (html === null) continue
+
+      out.set(userId, await filterView('signature.html', html, { ...viewer, authorId: userId }))
+    }
+    return out
+  } catch {
+    return new Map()
+  }
+}

package/src/server/sso-handshake.ts

@@ -0,0 +1,79 @@
+import { decodeBase64UrlText, encodeBase64Url, isProviderKind } from '@meith/accounts'
+
+import { isSafeLocalPath } from './safe-path'
+
+export type HandshakeMode = 'sign-in' | 'link' | 'credential-proof'
+
+export interface Handshake {
+  readonly provider: string
+  readonly mode: HandshakeMode
+  readonly state: string
+  readonly nonce: string
+  readonly codeVerifier: string
+  readonly next: string
+  readonly authorizationUrl: string
+  readonly userId?: number
+  readonly sessionId?: number
+  readonly provedAt?: number
+}
+
+export function isProviderAddress(value: string): boolean {
+  try {
+    const url = new URL(value)
+    return url.protocol === 'https:' || url.protocol === 'http:'
+  } catch {
+    return false
+  }
+}
+
+export function encodeHandshake(handshake: Handshake): string {
+  return encodeBase64Url(new TextEncoder().encode(JSON.stringify(handshake)))
+}
+
+export function decodeHandshake(raw: string | undefined): Handshake | null {
+  if (raw === undefined || raw === '') return null
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(decodeBase64UrlText(raw))
+  } catch {
+    return null
+  }
+
+  if (typeof parsed !== 'object' || parsed === null) return null
+  const candidate = parsed as Record<string, unknown>
+
+  const provider = text(candidate.provider)
+  const mode = candidate.mode
+  const state = text(candidate.state)
+  const nonce = text(candidate.nonce)
+  const codeVerifier = text(candidate.codeVerifier)
+  const next = text(candidate.next)
+  const authorizationUrl = text(candidate.authorizationUrl)
+
+  if (provider === null || !isProviderKind(provider)) return null
+  if (mode !== 'sign-in' && mode !== 'link' && mode !== 'credential-proof') return null
+  if (state === null || nonce === null || codeVerifier === null) return null
+  if (authorizationUrl === null || !isProviderAddress(authorizationUrl)) return null
+
+  return {
+    provider,
+    mode,
+    state,
+    nonce,
+    codeVerifier,
+    authorizationUrl,
+    next: next !== null && isSafeLocalPath(next) ? next : '/',
+    ...(integer(candidate.userId) === null ? {} : { userId: integer(candidate.userId)! }),
+    ...(integer(candidate.sessionId) === null ? {} : { sessionId: integer(candidate.sessionId)! }),
+    ...(integer(candidate.provedAt) === null ? {} : { provedAt: integer(candidate.provedAt)! }),
+  }
+}
+
+function integer(value: unknown): number | null {
+  return typeof value === 'number' && Number.isInteger(value) ? value : null
+}
+
+function text(value: unknown): string | null {
+  return typeof value === 'string' && value !== '' ? value : null
+}

package/src/server/stats.ts

@@ -0,0 +1,63 @@
+import 'server-only'
+
+import type { Actor } from '@meith/authorization'
+import { contentScopeFrom } from '@meith/core'
+import {
+  type BoardTotals,
+  getDb,
+  PostgresStatsRepository,
+  type StatsScope,
+  type TopPoster,
+  type TopThread,
+} from '@meith/db'
+
+import { getContainer } from './container'
+
+export const LEADERBOARD_SIZE = 10
+
+export function statsRepository(): PostgresStatsRepository | null {
+  return getContainer().dataSource === 'postgres' ? new PostgresStatsRepository(getDb()) : null
+}
+
+export async function statsScopeFor(actor: Actor): Promise<StatsScope> {
+  const { authorizer } = getContainer()
+  const staff = actor.global.isAdministrator === true || actor.global.isSuperModerator === true
+
+  return {
+    ...(await authorizer.threadAudience(actor)),
+    content: contentScopeFrom({ seesUnapproved: staff, seesDeleted: staff }),
+  }
+}
+
+export interface StatsView {
+  readonly totals: BoardTotals
+  readonly topPosters: readonly TopPoster[]
+  readonly mostViewed: readonly TopThread[]
+  readonly mostReplied: readonly TopThread[]
+}
+
+export async function buildStatsView(actor: Actor): Promise<StatsView | null> {
+  const repo = statsRepository()
+  if (repo === null) return null
+
+  const scope = await statsScopeFor(actor)
+  const [totals, topPosters, mostViewed, mostReplied] = await Promise.all([
+    repo.readTotals(),
+    repo.topPosters(LEADERBOARD_SIZE),
+    repo.mostViewed(LEADERBOARD_SIZE, scope),
+    repo.mostReplied(LEADERBOARD_SIZE, scope),
+  ])
+
+  return { totals, topPosters, mostViewed, mostReplied }
+}
+
+export async function readTotals(): Promise<BoardTotals | null> {
+  const repo = statsRepository()
+  if (repo === null) return null
+
+  try {
+    return await repo.readTotals()
+  } catch {
+    return null
+  }
+}

package/src/server/subscription-actions.ts

@@ -0,0 +1,161 @@
+'use server'
+
+import { redirect } from 'next/navigation'
+
+import { env, ForbiddenError } from '@meith/core'
+import { currentRequestId } from '@meith/core/logger'
+import { msg } from '@meith/i18n'
+import {
+  parseSubscriptionTarget,
+  readUnsubscribeToken,
+  SubscriptionService,
+} from '@meith/subscriptions'
+
+import type { FormState } from './auth-form-state'
+import { getContainer } from './container'
+import { getActor } from './context'
+import { formStateReporter } from './form-state-reporter'
+import { positiveInt, text } from './form-values'
+import { tr } from './i18n'
+import { emitEvent } from './plugin-view'
+import { isSafeLocalPath } from './safe-path'
+
+const toFormState = formStateReporter('subscription-actions', 'unexpected error in subscriptions')
+
+async function mayView(target: 'thread' | 'forum', targetId: number): Promise<boolean> {
+  const actor = await getActor()
+  const { authorizer, threads, forums } = getContainer()
+
+  const located = target === 'forum' ? null : await threads.locate(targetId)
+  const forumId = target === 'forum' ? targetId : (located?.forumId ?? null)
+  if (forumId === null) return false
+
+  const forum = await forums.findById(forumId)
+  if (!forum) return false
+
+  const matrix = await authorizer.forumMatrix(actor, forumId)
+  return target === 'forum'
+    ? authorizer.can(actor, 'forum.view', { forumId, forum: matrix })
+    : authorizer.can(actor, 'thread.view', {
+        ...(await authorizer.moderatorTargetIn(actor, forumId, matrix)),
+        threadAuthorId: located?.authorUserId ?? null,
+      })
+}
+
+export async function subscribeAction(_prev: FormState, form: FormData): Promise<FormState> {
+  const target = parseSubscriptionTarget(text(form, 'target'))
+  const targetId = positiveInt(form, 'targetId')
+  const back = text(form, 'back')
+
+  if (target === null || targetId === null) return { error: await tr('notice.app.exist') }
+
+  try {
+    const actor = await getActor()
+    if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+
+    const { subscriptions } = getContainer()
+    if (subscriptions === null) {
+      throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-17'))
+    }
+
+    await new SubscriptionService({ subscriptions }).subscribe({
+      userId: actor.userId,
+      target,
+      targetId,
+      mode: text(form, 'mode'),
+      mayView: await mayView(target, targetId),
+    })
+
+    await emitEvent(
+      'subscription.changed',
+      { userId: actor.userId, target, targetId, subscribed: true },
+      { requestId: currentRequestId() ?? null },
+    )
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect(safeReturn(back, '/subscriptions?followed=1'))
+}
+
+export async function unsubscribeAction(_prev: FormState, form: FormData): Promise<FormState> {
+  const target = parseSubscriptionTarget(text(form, 'target'))
+  const targetId = positiveInt(form, 'targetId')
+  const back = text(form, 'back')
+
+  if (target === null || targetId === null) return { error: await tr('notice.app.exist') }
+
+  try {
+    const actor = await getActor()
+    if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+
+    const { subscriptions } = getContainer()
+    if (subscriptions === null) {
+      throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-17'))
+    }
+
+    await new SubscriptionService({ subscriptions }).unsubscribe({
+      userId: actor.userId,
+      target,
+      targetId,
+    })
+
+    await emitEvent(
+      'subscription.changed',
+      { userId: actor.userId, target, targetId, subscribed: false },
+      { requestId: currentRequestId() ?? null },
+    )
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect(safeReturn(back, '/subscriptions?stopped=1'))
+}
+
+export async function unsubscribeByTokenAction(
+  _prev: FormState,
+  form: FormData,
+): Promise<FormState> {
+  const token = text(form, 'token')
+  const secret = env.AUTH_SECRET
+
+  if (secret === undefined || token === '') {
+    return { error: await tr('notice.app.unsubscribe-link-valid') }
+  }
+
+  const claim = readUnsubscribeToken(token, secret)
+  if (claim === null) return { error: await tr('notice.app.unsubscribe-link-valid') }
+
+  try {
+    const { subscriptions, notifications } = getContainer()
+    if (subscriptions === null || notifications === null) {
+      throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-17'))
+    }
+
+    if (claim.scope === 'email') {
+      await notifications.savePreferences(
+        claim.userId,
+        'email',
+        new Map([
+          ['subscription.reply', false],
+          ['subscription.digest', false],
+        ]),
+      )
+    } else {
+      await new SubscriptionService({ subscriptions }).unsubscribe({
+        userId: claim.userId,
+        target: claim.scope,
+        targetId: claim.targetId,
+      })
+    }
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect(`/unsubscribe?done=${claim.scope === 'email' ? 'email' : 'one'}`)
+}
+
+function safeReturn(value: string, fallback: string): string {
+  if (!isSafeLocalPath(value)) return fallback
+  return value
+}

package/src/server/surgery-actions.ts

@@ -0,0 +1,180 @@
+'use server'
+
+import { redirect } from 'next/navigation'
+
+import { ForbiddenError, ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+import { parseSelection, type SurgeryRights, ThreadSurgery } from '@meith/moderation'
+
+import type { FormState } from './auth-form-state'
+import { getContainer } from './container'
+import { getActor } from './context'
+import { formStateReporter } from './form-state-reporter'
+import { tr } from './i18n'
+import { emitEvent } from './plugin-view'
+
+function positiveInt(form: FormData, name: string): number | null {
+  const value = form.get(name)
+  if (typeof value !== 'string' || !/^[1-9]\d*$/.test(value.trim())) return null
+  const n = Number(value.trim())
+  return Number.isSafeInteger(n) ? n : null
+}
+
+const toFormState = formStateReporter('surgery-actions', 'unexpected error in thread surgery')
+
+const NO_STORE = 'This board is running on in-memory sample data, so it has no thread tools.'
+
+export async function splitThreadAction(_prev: FormState, form: FormData): Promise<FormState> {
+  const threadId = positiveInt(form, 'threadId')
+  const fromPostId = positiveInt(form, 'fromPostId')
+  const title = typeof form.get('title') === 'string' ? (form.get('title') as string) : ''
+
+  if (threadId === null) return { error: await tr('notice.app.thread-exist') }
+  if (fromPostId === null) return { error: await tr('notice.app.choose-post-split-from') }
+
+  const { threadSurgery } = getContainer()
+  if (threadSurgery === null) return { error: NO_STORE }
+
+  let outcome: Awaited<ReturnType<ThreadSurgery['split']>>
+  try {
+    const actor = await getActor()
+    if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+
+    const forumId = await visibleForumOf(threadId)
+
+    outcome = await new ThreadSurgery({ threads: threadSurgery }).split({
+      threadId,
+      fromPostId,
+      title,
+      actorUserId: actor.userId,
+      rights: await resolveRights(forumId),
+    })
+
+    await emitEvent(
+      'thread.split',
+      { sourceThreadId: threadId, newThreadId: outcome.threadId, postCount: outcome.posts },
+      { moderatorId: actor.userId, reason: null },
+    )
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect(`/thread/${outcome.threadId}-${outcome.slug}?tool=split&n=${outcome.posts}`)
+}
+
+export async function splitSelectedAction(_prev: FormState, form: FormData): Promise<FormState> {
+  const threadId = positiveInt(form, 'threadId')
+  const title = typeof form.get('title') === 'string' ? (form.get('title') as string) : ''
+  if (threadId === null) return { error: await tr('notice.app.thread-exist') }
+
+  const { threadSurgery } = getContainer()
+  if (threadSurgery === null) return { error: NO_STORE }
+
+  const postIds = parseSelection(
+    form.getAll('item').filter((v): v is string => typeof v === 'string'),
+  )
+    .filter((item) => item.kind === 'post')
+    .map((item) => item.id)
+
+  let outcome: Awaited<ReturnType<ThreadSurgery['splitPosts']>>
+  try {
+    const actor = await getActor()
+    if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+
+    const forumId = await visibleForumOf(threadId)
+
+    outcome = await new ThreadSurgery({ threads: threadSurgery }).splitPosts({
+      threadId,
+      postIds,
+      title,
+      actorUserId: actor.userId,
+      rights: await resolveRights(forumId),
+    })
+
+    await emitEvent(
+      'thread.split',
+      { sourceThreadId: threadId, newThreadId: outcome.threadId, postCount: outcome.posts },
+      { moderatorId: actor.userId, reason: null },
+    )
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  const dropped = outcome.dropped > 0 ? `&dropped=${outcome.dropped}` : ''
+  redirect(`/thread/${outcome.threadId}-${outcome.slug}?tool=split&n=${outcome.posts}${dropped}`)
+}
+
+export async function mergeThreadAction(_prev: FormState, form: FormData): Promise<FormState> {
+  const sourceThreadId = positiveInt(form, 'threadId')
+  const targetThreadId = positiveInt(form, 'targetThreadId')
+
+  if (sourceThreadId === null) return { error: await tr('notice.app.thread-exist') }
+  if (targetThreadId === null) {
+    return { error: await tr('notice.app.enter-number-thread-merge-into') }
+  }
+
+  const { threadSurgery } = getContainer()
+  if (threadSurgery === null) return { error: NO_STORE }
+
+  let outcome: Awaited<ReturnType<ThreadSurgery['merge']>>
+  try {
+    const actor = await getActor()
+    if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+
+    const [sourceForumId, targetForumId] = await Promise.all([
+      visibleForumOf(sourceThreadId),
+      visibleForumOf(targetThreadId),
+    ])
+
+    outcome = await new ThreadSurgery({ threads: threadSurgery }).merge({
+      sourceThreadId,
+      targetThreadId,
+      actorUserId: actor.userId,
+      rights: await resolveRights(sourceForumId),
+      targetRights: await resolveRights(targetForumId),
+    })
+
+    await emitEvent(
+      'thread.merged',
+      {
+        keptThreadId: outcome.threadId,
+        mergedThreadId: sourceThreadId,
+        postCount: outcome.posts,
+      },
+      { moderatorId: actor.userId, reason: null },
+    )
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect(`/thread/${outcome.threadId}-${outcome.slug}?tool=merge&n=${outcome.posts}`)
+}
+
+async function visibleForumOf(threadId: number): Promise<number> {
+  const { threads, authorizer } = getContainer()
+  const actor = await getActor()
+
+  const forumId = (await threads.locate(threadId))?.forumId ?? null
+  if (forumId === null) throw new ValidationError(msg('error.app.thread-exist'))
+
+  const forum = await authorizer.forumMatrix(actor, forumId)
+  if (!authorizer.can(actor, 'thread.view', { forumId, forum })) {
+    throw new ValidationError(msg('error.app.thread-exist'))
+  }
+  return forumId
+}
+
+async function resolveRights(forumId: number): Promise<SurgeryRights> {
+  const actor = await getActor()
+  const { authorizer } = getContainer()
+  const [forum, moderatorRights] = await Promise.all([
+    authorizer.forumMatrix(actor, forumId),
+    authorizer.moderatorRightsIn(actor, forumId),
+  ])
+  const target = { forumId, forum, moderatorRights }
+
+  return {
+    merge: authorizer.can(actor, 'thread.merge', target),
+    split: authorizer.can(actor, 'thread.split', target),
+  }
+}

package/src/server/syndication.ts

@@ -0,0 +1,77 @@
+import 'server-only'
+
+import { env, PUBLIC_CONTENT } from '@meith/core'
+import { type FeedScope, getDb, PostgresFeedRepository } from '@meith/db'
+
+import type { SitemapUrl } from '@/view/feed'
+
+import { boardUrl } from './board-url'
+import { getContainer } from './container'
+import { filterView } from './plugin-view'
+import { getSettings } from './settings'
+
+export const FEED_LIMIT = 30
+
+export const SITEMAP_CHUNK = 5_000
+
+export function feedRepository(): PostgresFeedRepository | null {
+  return getContainer().dataSource === 'postgres' ? new PostgresFeedRepository(getDb()) : null
+}
+
+export async function origin(): Promise<string> {
+  return (await boardUrl()) || 'http://localhost:3000'
+}
+
+export function absoluteTo(base: string, path: string): string {
+  return `${base}${path}`
+}
+
+export async function absolute(path: string): Promise<string> {
+  return absoluteTo(await origin(), path)
+}
+
+export async function publicScope(): Promise<FeedScope> {
+  const { authorizer, actorSource } = getContainer()
+  const guest = await actorSource.buildGuest()
+
+  return {
+    ...(await authorizer.threadAudience(guest)),
+    content: PUBLIC_CONTENT,
+  }
+}
+
+export async function isIndexable(): Promise<boolean> {
+  if (env.DEMO_MODE) return false
+
+  try {
+    return (await getSettings()).get('board.offline') !== true
+  } catch {
+    return true
+  }
+}
+
+/**
+ * One chunk of the sitemap, after the plugins have had it. Everything here is
+ * public by definition — the sitemap is what the board offers a crawler.
+ */
+export async function filterSitemapEntries(
+  urls: readonly SitemapUrl[],
+  chunk: number,
+): Promise<readonly SitemapUrl[]> {
+  const filtered = await filterView(
+    'sitemap.entries',
+    urls.map((url) => ({
+      href: url.loc,
+      lastModified: url.lastmod?.toISOString() ?? null,
+    })),
+    { chunk },
+  )
+
+  return filtered.map((row) => {
+    const lastmod = row.lastModified === null ? undefined : new Date(row.lastModified)
+    return {
+      loc: row.href,
+      ...(lastmod === undefined || Number.isNaN(lastmod.getTime()) ? {} : { lastmod }),
+    }
+  })
+}