@meith/web 0.16.0

package/src/server/reputation.ts

@@ -0,0 +1,70 @@
+import 'server-only'
+
+import type { Actor } from '@meith/authorization'
+import type { RaterLimits, ReputationSettings } from '@meith/reputation'
+import { ReputationService } from '@meith/reputation'
+
+import { getContainer } from './container'
+import { getActor } from './context'
+import { getSettings } from './settings'
+
+export function reputationService(): ReputationService | null {
+  const { reputation } = getContainer()
+  return reputation === null ? null : new ReputationService({ reputation })
+}
+
+export async function reputationSettings(): Promise<ReputationSettings> {
+  const settings = await getSettings()
+  return {
+    enabled: settings.get('reputation.enabled'),
+    allowNegative: settings.get('reputation.allow_negative'),
+    commentRequired: settings.get('reputation.comment_required'),
+    minPostsToGive: settings.get('reputation.min_posts_to_give'),
+  }
+}
+
+export async function viewerRaterLimits(viewer?: Actor): Promise<RaterLimits> {
+  const actor = viewer ?? (await getActor())
+  const { authorizer, memberProfiles } = getContainer()
+
+  if (actor.userId === null) return { canGive: false, maxPerDay: 0, postCount: 0 }
+
+  const profile = await memberProfiles.findPublicById(actor.userId).catch(() => null)
+
+  return {
+    canGive: authorizer.can(actor, 'reputation.give'),
+    maxPerDay: authorizer.globalLimit(actor, 'maxReputationPerDay'),
+    postCount: profile?.postCount ?? 0,
+  }
+}
+
+export interface PostThanks {
+  readonly thanked: boolean
+  readonly count: number
+}
+
+export async function thanksForPosts(
+  postIds: readonly number[],
+): Promise<ReadonlyMap<number, PostThanks>> {
+  const service = reputationService()
+  if (service === null || postIds.length === 0) return new Map()
+
+  const actor = await getActor()
+
+  const [counts, mine] = await Promise.all([
+    service.thanksForPosts(postIds).catch(() => new Map<number, number>()),
+    actor.userId === null
+      ? Promise.resolve(new Map())
+      : service.existingForPosts({ givenByUserId: actor.userId, postIds }).catch(() => new Map()),
+  ])
+
+  return new Map(
+    postIds.map((postId) => [
+      postId,
+      {
+        thanked: (mine.get(postId)?.points ?? 0) > 0,
+        count: counts.get(postId) ?? 0,
+      },
+    ]),
+  )
+}

package/src/server/request-fingerprint.ts

@@ -0,0 +1,65 @@
+import 'server-only'
+
+import { headers } from 'next/headers'
+
+import { env, logger, resolveClientAddress, truncateIp } from '@meith/core'
+import { demoAddressToken, demoDiscardsAddresses } from '@meith/demo'
+
+export interface RequestFingerprint {
+  readonly ipPrefix: string | null
+  readonly userAgent: string | null
+}
+
+let announcedUntrustedForwarding = false
+
+export async function remoteAddress(): Promise<string | null> {
+  const jar = await headers()
+  const forwarded = jar.get('x-forwarded-for')
+
+  if (env.TRUSTED_PROXY_HOPS === 0 && forwarded !== null && !announcedUntrustedForwarding) {
+    announcedUntrustedForwarding = true
+    logger({ module: 'request' }).warn(
+      'TRUSTED_PROXY_HOPS is 0 and a request arrived carrying X-Forwarded-For; ' +
+        'the header is being ignored. Set it to the number of proxies in front ' +
+        'of the board, or addresses will not resolve.',
+    )
+  }
+
+  return resolveClientAddress(
+    { forwardedFor: forwarded, realIp: jar.get('x-real-ip') },
+    env.TRUSTED_PROXY_HOPS,
+  )
+}
+
+export async function retainedIpPrefix(): Promise<string | null> {
+  if (demoDiscardsAddresses()) return null
+  return truncateIp(await remoteAddress()) ?? null
+}
+
+export async function countingPrefix(): Promise<string | null> {
+  const address = await remoteAddress()
+  if (address === null || address === '') return null
+
+  const prefix = truncateIp(address)
+  if (prefix === undefined) return null
+
+  return demoDiscardsAddresses() ? demoAddressToken(prefix) : prefix
+}
+
+export async function countingAddress(): Promise<string | null> {
+  const address = await remoteAddress()
+  if (address === null || address === '') return null
+
+  return demoDiscardsAddresses() ? demoAddressToken(address) : address
+}
+
+/** Where a request came from and what made it, as much as is kept about either. */
+export async function requestFingerprint(): Promise<RequestFingerprint> {
+  const incoming = await headers()
+  const agent = incoming.get('user-agent') ?? ''
+
+  return {
+    ipPrefix: await retainedIpPrefix(),
+    userAgent: agent.trim() === '' ? null : agent.slice(0, 300),
+  }
+}

package/src/server/safe-path.ts

@@ -0,0 +1,16 @@
+import 'server-only'
+
+export function isSafeLocalPath(path: string): boolean {
+  if (!path.startsWith('/') || path.startsWith('//')) return false
+
+  for (const character of path) {
+    const code = character.charCodeAt(0)
+    if (code <= 0x20 || code === 0x7f || character === '\\') return false
+  }
+
+  try {
+    return new URL(path, 'http://localhost').origin === 'http://localhost'
+  } catch {
+    return false
+  }
+}

package/src/server/same-origin.ts

@@ -0,0 +1,45 @@
+import 'server-only'
+
+function boardHost(request: Request): string | null {
+  const host = request.headers.get('x-forwarded-host') ?? request.headers.get('host')
+  if (host === null) return null
+
+  const trimmed = host.trim().toLowerCase()
+  return trimmed === '' ? null : trimmed
+}
+
+export function isSameOrigin(request: Request): boolean {
+  const origin = request.headers.get('origin')?.trim()
+
+  if (origin !== undefined && origin !== '' && origin !== 'null') {
+    const host = boardHost(request)
+    if (host === null) return false
+
+    try {
+      return new URL(origin).host.toLowerCase() === host
+    } catch {
+      return false
+    }
+  }
+
+  const site = request.headers.get('sec-fetch-site')
+  return site === 'same-origin' || site === 'none'
+}
+
+export function isTopLevelNavigation(request: Request): boolean {
+  const mode = request.headers.get('sec-fetch-mode')
+  const dest = request.headers.get('sec-fetch-dest')
+
+  if (mode !== null || dest !== null) {
+    return (mode === null || mode === 'navigate') && (dest === null || dest === 'document')
+  }
+
+  return (request.headers.get('accept') ?? '').includes('text/html')
+}
+
+export function crossOriginRefusal(): Response {
+  return new Response('This request did not come from the board.', {
+    status: 403,
+    headers: { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' },
+  })
+}

package/src/server/search-page.ts

@@ -0,0 +1,313 @@
+import { msg } from '@meith/i18n'
+import 'server-only'
+
+import { randomBytes } from 'node:crypto'
+
+import { foldIdentifier } from '@meith/accounts'
+import type { Actor } from '@meith/authorization'
+import { ForbiddenError, NotFoundError } from '@meith/core'
+import { getDb, ownsSearch, PostgresSearchStore, SEARCH_WINDOW, type StoredSearch } from '@meith/db'
+import {
+  isRefined,
+  isRunnable,
+  narrowFilters,
+  parseSearchInput,
+  readGrouping,
+  readMatch,
+  readPeriod,
+  readSort,
+  type SearchCursor,
+  type SearchFilterSet,
+  type SearchRefinement,
+  type SearchResults,
+  type SearchSummary,
+  searchQueryFrom,
+  trimRefinement,
+} from '@meith/search'
+
+import { REFINE_FIELDS } from '@/view/search-controls'
+
+import { limitMessage, spendLimit } from './antispam'
+import { getContainer } from './container'
+import { filterView, viewerRef } from './plugin-view'
+import { requireSearch, requireSearchEnabled, searchMinWordLength, searchScopeFor } from './search'
+import { getSettings } from './settings'
+
+export const SEARCH_PAGE = 20
+
+export const MAX_AUTHOR_NAMES = 5
+
+export const SEARCH_COUNT_CAP = SEARCH_WINDOW
+
+export function searchStore(): PostgresSearchStore | null {
+  return getContainer().dataSource === 'postgres' ? new PostgresSearchStore(getDb()) : null
+}
+
+function newToken(): string {
+  return randomBytes(18).toString('base64url')
+}
+
+export interface RunSearchInput {
+  readonly actor: Actor
+  readonly sessionKey: string | null
+  readonly terms: string
+  readonly filters: Omit<SearchFilterSet, 'authorUserIds' | 'authorNames'>
+  readonly authors: string
+}
+
+export type RunSearchOutcome =
+  | { readonly kind: 'ok'; readonly token: string }
+  | {
+      readonly kind: 'refused'
+      readonly reason: 'empty' | 'too-short' | 'too-long'
+      readonly minWordLength: number
+    }
+  | { readonly kind: 'flooded'; readonly seconds: number }
+  | { readonly kind: 'limited'; readonly message: string }
+  | { readonly kind: 'unknown-author'; readonly name: string }
+
+export async function runSearch(input: RunSearchInput): Promise<RunSearchOutcome> {
+  await requireSearchEnabled()
+
+  const minWordLength = await searchMinWordLength()
+
+  const parsed = parseSearchInput(input.terms, minWordLength)
+  if (!isRunnable(parsed)) {
+    return { kind: 'refused', reason: parsed.refusal ?? 'empty', minWordLength }
+  }
+
+  const store = searchStore()
+  if (store === null) throw new ForbiddenError(msg('error.app.board-search-index'))
+
+  const authors = await resolveAuthors(parseAuthorNames(input.authors))
+  if (authors.kind === 'unknown') return { kind: 'unknown-author', name: authors.name }
+
+  const settings = await getSettings()
+  const { authorizer } = getContainer()
+
+  const floodSeconds = authorizer.can(input.actor, 'flood.bypass')
+    ? 0
+    : Number(settings.get('search.flood_seconds') ?? 0)
+
+  const limited = await spendLimit({ scope: 'search', actor: input.actor, settings })
+  if (limited !== null && !limited.allowed) {
+    return { kind: 'limited', message: limitMessage(limited) }
+  }
+
+  const filters: SearchFilterSet = {
+    ...input.filters,
+    ...(authors.ids.length === 0 ? {} : { authorUserIds: authors.ids, authorNames: authors.names }),
+  }
+
+  const terms = await filterView('search.query.before', parsed.terms, viewerRef(input.actor))
+
+  const stored = await store.create({
+    token: newToken(),
+    userId: input.actor.userId,
+    sessionKey: input.sessionKey,
+    terms,
+    filters: { ...filters },
+    floodSeconds,
+  })
+
+  if (stored === null) return { kind: 'flooded', seconds: floodSeconds }
+
+  return { kind: 'ok', token: stored.token }
+}
+
+export interface SearchPageView {
+  readonly search: StoredSearch
+  readonly results: SearchResults
+  readonly summary: SearchSummary
+  readonly filters: SearchFilterSet
+  readonly effective: SearchFilterSet
+  readonly refine: SearchRefinement
+}
+
+export async function openSearch(input: {
+  readonly actor: Actor
+  readonly sessionKey: string | null
+  readonly token: string
+  readonly after: SearchCursor | null
+  readonly offset?: number
+  readonly refine: SearchRefinement
+  readonly now: Date
+}): Promise<SearchPageView> {
+  await requireSearchEnabled()
+
+  const store = searchStore()
+  if (store === null) throw new NotFoundError(msg('error.app.such-search'))
+
+  const search = await store.findByToken(input.token)
+  if (search === null) throw new NotFoundError(msg('error.app.such-search'))
+
+  if (!ownsSearch(search, { userId: input.actor.userId, sessionKey: input.sessionKey })) {
+    throw new NotFoundError(msg('error.app.such-search'))
+  }
+
+  const filters = readFilters(search.filters)
+  const refine = trimRefinement(input.refine, filters)
+  const effective = narrowFilters(filters, refine)
+  const scope = await searchScopeFor(input.actor)
+  const provider = requireSearch()
+
+  const [results, summary] = await Promise.all([
+    provider.search(
+      searchQueryFrom(search.terms, effective, {
+        limit: SEARCH_PAGE,
+        after: input.after,
+        ...(input.offset === undefined ? {} : { offset: input.offset }),
+        now: input.now,
+      }),
+      scope,
+    ),
+    provider.summarize(
+      searchQueryFrom(search.terms, facetFilters(filters, refine), {
+        limit: SEARCH_PAGE,
+        after: null,
+        now: input.now,
+      }),
+      scope,
+    ),
+  ])
+
+  if (!isRefined(refine) && search.hitCount !== summary.total) {
+    await store.recordHitCount(search.id, summary.total)
+  }
+
+  return {
+    search,
+    results: await filterHits(results, search.terms, input.actor),
+    summary,
+    filters,
+    effective,
+    refine,
+  }
+}
+
+/**
+ * A plugin may reorder or drop; a row it invents has no hit behind it and is
+ * dropped, because the hits arrived permission-filtered in SQL.
+ */
+async function filterHits(
+  results: SearchResults,
+  terms: string,
+  actor: Actor,
+): Promise<SearchResults> {
+  const ordered = await filterView(
+    'search.results',
+    results.hits.map((hit) => ({ postId: hit.postId, threadId: hit.threadId, rank: hit.rank })),
+    { ...viewerRef(actor), terms },
+  )
+
+  const byPostId = new Map(results.hits.map((hit) => [hit.postId, hit]))
+  const hits = ordered
+    .map((row) => byPostId.get(row.postId))
+    .filter((hit): hit is (typeof results.hits)[number] => hit !== undefined)
+
+  return { ...results, hits }
+}
+
+function facetFilters(filters: SearchFilterSet, refine: SearchRefinement): SearchFilterSet {
+  return narrowFilters(filters, {
+    ...refine,
+    forumIds: undefined,
+    authorUserIds: undefined,
+  })
+}
+
+export function readFilters(raw: Readonly<Record<string, unknown>>): SearchFilterSet {
+  const forumIds = ids(raw.forumIds)
+  const authorUserIds = ids(raw.authorUserIds)
+  const authorNames = names(raw.authorNames)
+
+  return {
+    sort: readSort(raw.sort),
+    match: readMatch(raw.match),
+    grouping: readGrouping(raw.grouping),
+    period: readPeriod(raw.period),
+    ...(forumIds === undefined ? {} : { forumIds }),
+    ...(authorUserIds === undefined ? {} : { authorUserIds }),
+    ...(authorNames === undefined ? {} : { authorNames }),
+  }
+}
+
+export function readRefinement(
+  params: Readonly<Record<string, string | string[] | undefined>>,
+): SearchRefinement {
+  const many = (key: string): readonly string[] => {
+    const raw = params[key]
+    if (raw === undefined) return []
+    return (Array.isArray(raw) ? raw : [raw]).filter((value) => value !== '')
+  }
+  const one = (key: string): string | undefined => many(key)[0]
+
+  const chosen = (key: string): readonly number[] | undefined => {
+    const values = many(key)
+      .map((value) => Number(value))
+      .filter((value) => Number.isSafeInteger(value) && value > 0)
+
+    return values.length === 0 ? undefined : values
+  }
+
+  const forumIds = chosen(REFINE_FIELDS.forum)
+  const authorUserIds = chosen(REFINE_FIELDS.author)
+
+  const sort = one(REFINE_FIELDS.sort)
+  const grouping = one(REFINE_FIELDS.grouping)
+  const match = one(REFINE_FIELDS.match)
+  const period = one(REFINE_FIELDS.period)
+
+  return {
+    ...(sort === undefined ? {} : { sort: readSort(sort) }),
+    ...(grouping === undefined ? {} : { grouping: readGrouping(grouping) }),
+    ...(match === undefined || readMatch(match) === 'everything'
+      ? {}
+      : { match: readMatch(match) }),
+    ...(period === undefined || readPeriod(period) === 'any' ? {} : { period: readPeriod(period) }),
+    ...(forumIds === undefined ? {} : { forumIds }),
+    ...(authorUserIds === undefined ? {} : { authorUserIds }),
+  }
+}
+
+export function parseAuthorNames(raw: string): readonly string[] {
+  return raw
+    .split(',')
+    .map((name) => name.trim())
+    .filter((name) => name !== '')
+    .slice(0, MAX_AUTHOR_NAMES)
+}
+
+async function resolveAuthors(
+  wanted: readonly string[],
+): Promise<
+  | { readonly kind: 'ok'; readonly ids: readonly number[]; readonly names: readonly string[] }
+  | { readonly kind: 'unknown'; readonly name: string }
+> {
+  if (wanted.length === 0) return { kind: 'ok', ids: [], names: [] }
+
+  const { accountStore } = getContainer()
+  const ids: number[] = []
+  const found: string[] = []
+
+  for (const name of wanted) {
+    const account = await accountStore.accounts.findByUsernameLower(foldIdentifier(name))
+    if (account === null) return { kind: 'unknown', name }
+    ids.push(account.id)
+    found.push(account.username)
+  }
+
+  return { kind: 'ok', ids, names: found }
+}
+
+function ids(value: unknown): readonly number[] | undefined {
+  return Array.isArray(value) && value.every((entry) => Number.isSafeInteger(entry))
+    ? (value as number[])
+    : undefined
+}
+
+function names(value: unknown): readonly string[] | undefined {
+  return Array.isArray(value) && value.every((entry) => typeof entry === 'string')
+    ? (value as string[])
+    : undefined
+}

package/src/server/search.ts

@@ -0,0 +1,45 @@
+import { msg } from '@meith/i18n'
+import 'server-only'
+
+import type { Actor } from '@meith/authorization'
+import { contentScopeFrom, ForbiddenError } from '@meith/core'
+import { getDb, PostgresSearchRepository } from '@meith/db'
+import type { SearchScope } from '@meith/search'
+
+import { getContainer } from './container'
+import { getSettings } from './settings'
+
+export async function searchEnabled(): Promise<boolean> {
+  return (await getSettings()).get('search.enabled') === true
+}
+
+export async function requireSearchEnabled(): Promise<void> {
+  if (!(await searchEnabled())) throw new ForbiddenError(msg('board.search.disabled'))
+}
+
+export async function searchMinWordLength(): Promise<number> {
+  return (await getSettings()).get('search.min_word_length')
+}
+
+export function searchProvider(): PostgresSearchRepository | null {
+  return getContainer().dataSource === 'postgres' ? new PostgresSearchRepository(getDb()) : null
+}
+
+export function requireSearch(): PostgresSearchRepository {
+  const provider = searchProvider()
+  if (provider === null) {
+    throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-11'))
+  }
+  return provider
+}
+
+export async function searchScopeFor(actor: Actor): Promise<SearchScope> {
+  const { authorizer } = getContainer()
+
+  const staff = actor.global.isAdministrator === true || actor.global.isSuperModerator === true
+
+  return {
+    ...(await authorizer.threadAudience(actor)),
+    content: contentScopeFrom({ seesUnapproved: staff, seesDeleted: staff }),
+  }
+}

package/src/server/secret-auth.ts

@@ -0,0 +1,20 @@
+import { timingSafeEqual } from 'node:crypto'
+
+export function secretMatches(presented: string, expected: string): boolean {
+  const a = Buffer.from(presented, 'utf8')
+  const b = Buffer.from(expected, 'utf8')
+  if (a.length !== b.length) {
+    timingSafeEqual(b, b)
+    return false
+  }
+  return timingSafeEqual(a, b)
+}
+
+export function bearerSecret(request: Request, headerName: string): string {
+  const authorization = request.headers.get('authorization')
+  if (authorization !== null && /^Bearer\s+/i.test(authorization)) {
+    return authorization.replace(/^Bearer\s+/i, '')
+  }
+
+  return request.headers.get(headerName) ?? ''
+}

package/src/server/see-other.ts

@@ -0,0 +1,11 @@
+import 'server-only'
+
+import { isSafeLocalPath } from './safe-path'
+
+export function seeOther(path: string): Response {
+  if (!isSafeLocalPath(path)) {
+    throw new Error(`seeOther expects a path on this board, got: ${path}`)
+  }
+
+  return new Response(null, { status: 303, headers: { location: path } })
+}