@meith/web 0.16.0

package/src/server/poll-scope.ts

@@ -0,0 +1,52 @@
+import 'server-only'
+
+import type { Actor } from '@meith/authorization'
+import { canHoldThreads } from '@meith/forums'
+import type { PollEditCapabilities } from '@meith/polls'
+
+import { getContainer } from './container'
+import { moderatorTargetFor } from './modcp'
+
+export interface PollScope {
+  readonly forumId: number
+  readonly threadAuthorId: number | null
+  readonly mayVote: boolean
+  readonly mayEdit: boolean
+  readonly capabilities: PollEditCapabilities
+}
+
+export async function resolvePollScope(actor: Actor, threadId: number): Promise<PollScope | null> {
+  const { authorizer, forums, threads } = getContainer()
+
+  const located = await threads.locate(threadId)
+  if (located === null) return null
+
+  const forum = await forums.findById(located.forumId)
+  if (forum === null || !canHoldThreads(forum.type)) return null
+
+  const matrix = await authorizer.forumMatrix(actor, forum.id)
+  const scope = {
+    ...(await moderatorTargetFor(actor, forum.id, matrix)),
+    threadAuthorId: located.authorUserId,
+    ownerId: located.authorUserId,
+  }
+  if (!authorizer.can(actor, 'thread.view', scope)) return null
+
+  const wroteIt = actor.userId !== null && located.authorUserId === actor.userId
+  const editsOwn = wroteIt && authorizer.can(actor, 'post.editOwn', scope)
+  const mayEditOthers = authorizer.can(actor, 'post.editOthers', scope)
+  const moderates = authorizer.can(actor, 'content.viewUnapproved', scope)
+
+  return {
+    forumId: forum.id,
+    threadAuthorId: located.authorUserId,
+    mayVote: authorizer.can(actor, 'poll.vote', scope),
+    mayEdit: editsOwn || mayEditOthers,
+    capabilities: {
+      isAuthor: editsOwn,
+      mayEditOthers,
+      editWindowMinutes: Number(matrix.editTimeLimitMinutes ?? 0),
+      bypassesWindow: mayEditOthers || moderates,
+    },
+  }
+}

package/src/server/post-notifications.ts

@@ -0,0 +1,71 @@
+import 'server-only'
+
+import { foldIdentifier } from '@meith/accounts'
+import { logger } from '@meith/core'
+import { extractMentions, extractQuotedAuthors, vocabularyOptions } from '@meith/markdown'
+
+import { postLink } from '@/view/post-link'
+
+import { getContainer } from './container'
+import { activeVocabulary } from './content-admin'
+import { notificationService } from './notifications'
+
+const MAX_RECIPIENTS_PER_KIND = 10
+
+export interface NewPostNotice {
+  readonly postId: number
+  readonly threadId: number
+  readonly threadSlug: string
+  readonly threadTitle: string
+  readonly message: string
+  readonly authorUsername: string
+  readonly visibility: 'visible' | 'unapproved'
+}
+
+export async function notifyPostAudience(notice: NewPostNotice): Promise<void> {
+  try {
+    const service = notificationService()
+    if (service === null) return
+    if (notice.visibility !== 'visible') return
+
+    const options = vocabularyOptions(await activeVocabulary())
+    const quoted = extractQuotedAuthors(notice.message, options)
+    const mentioned = extractMentions(notice.message, options)
+
+    const href = postLink(`/thread/${notice.threadId}-${notice.threadSlug}`, notice.postId)
+    const data = { byUsername: notice.authorUsername, threadTitle: notice.threadTitle }
+
+    const { accountStore } = getContainer()
+    const told = new Set<string>([foldIdentifier(notice.authorUsername)])
+
+    for (const [kind, names] of [
+      ['post.quoted', quoted],
+      ['post.mentioned', mentioned],
+    ] as const) {
+      let raised = 0
+      for (const name of names) {
+        if (raised >= MAX_RECIPIENTS_PER_KIND) break
+        const folded = foldIdentifier(name)
+        if (told.has(folded)) continue
+        told.add(folded)
+
+        const account = await accountStore.accounts.findByUsernameLower(folded)
+        if (account === null) continue
+
+        await service.raise({
+          userId: account.id,
+          kind,
+          data,
+          href,
+          dedupeKey: `${kind}:${notice.postId}`,
+        })
+        raised += 1
+      }
+    }
+  } catch (err) {
+    logger({ module: 'post-notifications' }).error(
+      { err, postId: notice.postId },
+      'failed to raise mention/quote notifications',
+    )
+  }
+}

package/src/server/post-scope.ts

@@ -0,0 +1,86 @@
+import 'server-only'
+
+import type { Actor } from '@meith/authorization'
+import { type EditCapabilities, PostEditor, type PostWriteRepository } from '@meith/posts'
+
+import { getContainer } from './container'
+import { getActor } from './context'
+import { moderatorTargetFor } from './modcp'
+import { getSettings } from './settings'
+
+export interface PostManageScope {
+  readonly target: NonNullable<Awaited<ReturnType<PostWriteRepository['findEditTarget']>>>
+  readonly isOwn: boolean
+  readonly mayEdit: boolean
+  readonly mayDelete: boolean
+  readonly mayRestore: boolean
+  readonly mayViewHistory: boolean
+  readonly mayRollback: boolean
+  readonly capabilities: EditCapabilities
+  readonly bypassesLock: boolean
+}
+
+export async function resolvePostScope(
+  threadId: number,
+  postId: number,
+  viewer?: Actor,
+): Promise<PostManageScope | null> {
+  const actor = viewer ?? (await getActor())
+  const { authorizer, postWrites } = getContainer()
+  if (postWrites === null) return null
+
+  const target = await postWrites.findEditTarget(threadId, postId)
+  if (!target) return null
+
+  const matrix = await authorizer.forumMatrix(actor, target.forum.id)
+  const scope = {
+    ...(await moderatorTargetFor(actor, target.forum.id, matrix)),
+    ownerId: target.post.authorUserId,
+  }
+  if (!authorizer.can(actor, 'thread.view', scope)) return null
+
+  const isOwn = actor.userId !== null && target.post.authorUserId === actor.userId
+  const editsOthers = authorizer.can(actor, 'post.editOthers', scope)
+  const moderates = authorizer.can(actor, 'content.viewUnapproved', scope)
+  const softDeletes = authorizer.can(actor, 'post.softDelete', scope)
+  const seesUnapproved = authorizer.can(actor, 'content.viewUnapproved', scope)
+  const seesDeleted = authorizer.can(actor, 'content.viewDeleted', scope)
+  const staffCanSeePost =
+    editsOthers &&
+    (target.post.visibility === 'visible' ||
+      (target.post.visibility === 'unapproved' && seesUnapproved) ||
+      (target.post.visibility === 'deleted' && seesDeleted))
+
+  return {
+    target,
+    isOwn,
+    mayEdit: isOwn ? authorizer.can(actor, 'post.editOwn', scope) : editsOthers,
+    mayDelete: isOwn ? authorizer.can(actor, 'post.deleteOwn', scope) || softDeletes : softDeletes,
+    mayRestore:
+      authorizer.can(actor, 'post.restore', scope) &&
+      authorizer.can(actor, 'content.viewDeleted', scope),
+    mayViewHistory: (isOwn && target.post.visibility === 'visible') || staffCanSeePost,
+    mayRollback: staffCanSeePost && target.post.visibility !== 'deleted',
+    bypassesLock: moderates,
+    capabilities: {
+      isOwn,
+      editWindowMinutes: Number(scope.forum.editTimeLimitMinutes ?? 0),
+      bypassesWindow: editsOthers || moderates,
+      bypassesLock: moderates,
+      requiresApprovalOnEdit: scope.forum.requiresApprovalOnEdit === true,
+      bypassesModeration: moderates,
+    },
+  }
+}
+
+export async function postEditor(posts: PostWriteRepository): Promise<PostEditor> {
+  const settings = await getSettings()
+
+  return new PostEditor({
+    posts,
+    config: {
+      maxLength: settings.get('posting.max_length'),
+      editGraceSeconds: settings.get('posting.edit_grace_seconds'),
+    },
+  })
+}

package/src/server/presence.ts

@@ -0,0 +1,177 @@
+import 'server-only'
+
+import { createHash } from 'node:crypto'
+
+import { cookies, headers } from 'next/headers'
+
+import type { Actor } from '@meith/authorization'
+import { contentScopeFrom, env } from '@meith/core'
+import { getDb, type OnlineScope, type OnlineSnapshot, PostgresPresenceRepository } from '@meith/db'
+
+import { getContainer } from './container'
+import { clearedCookie, GUEST_COOKIE_DAYS, guestCookieName, sessionCookieName } from './cookies'
+import { FRESH_GUEST_HEADER, PATH_HEADER } from './location-header'
+
+const LOCATION_WINDOW_SECONDS = 60
+
+export interface BoardLocation {
+  readonly path: string
+  readonly forumId: number | null
+  readonly threadId: number | null
+}
+
+export function parseLocation(path: string | null): BoardLocation | null {
+  if (path === null || path === '') return null
+
+  const clean = path.split('?')[0] ?? path
+
+  const forum = /^\/(\d+)(?:-|\/|$)/.exec(clean)
+  const thread = /^\/thread\/(\d+)-/.exec(clean)
+
+  return {
+    path: clean,
+    forumId: forum === null ? null : Number(forum[1]),
+    threadId: thread === null ? null : Number(thread[1]),
+  }
+}
+
+export async function touchCurrentLocation(): Promise<void> {
+  try {
+    const location = parseLocation((await headers()).get(PATH_HEADER))
+    if (location === null) return
+    await touchLocation(location)
+  } catch {
+    /* ignore */
+  }
+}
+
+export function presenceRepository(): PostgresPresenceRepository | null {
+  return getContainer().dataSource === 'postgres' ? new PostgresPresenceRepository(getDb()) : null
+}
+
+export async function touchLocation(location: BoardLocation): Promise<void> {
+  try {
+    const { identity, accountStore } = getContainer()
+    const secure = env.NODE_ENV !== 'development'
+
+    const jar = await cookies()
+    const token = jar.get(sessionCookieName(secure))?.value
+
+    if (token === undefined || token === '') {
+      await touchGuestLocation(await returnedGuestToken(secure), location)
+      return
+    }
+
+    const session = await identity.locateSession(token)
+    if (session === null) {
+      await touchGuestLocation(await returnedGuestToken(secure), location)
+      return
+    }
+
+    await accountStore.sessions.touchLocation(
+      session.sessionId,
+      {
+        path: location.path,
+        forumId: location.forumId,
+        threadId: location.threadId,
+      },
+      new Date(),
+      LOCATION_WINDOW_SECONDS,
+    )
+  } catch {
+    /* ignore */
+  }
+}
+
+/**
+ * The guest token, but only once the client has proved it keeps cookies.
+ *
+ * The freshness header is the proof, and it has to come from the middleware
+ * because nothing downstream can supply it: Next reflects a cookie set on a
+ * `NextResponse.next()` into the request the render sees, so on a first-ever
+ * visit both `cookies()` and the raw `Cookie` header already carry a token the
+ * client has never seen. Counting on that wrote one presence row per request
+ * from anything that discards cookies — measured at twelve rows from twelve
+ * crawler requests, and a sessions table that grows without bound.
+ */
+async function returnedGuestToken(secure: boolean): Promise<string | undefined> {
+  if ((await headers()).get(FRESH_GUEST_HEADER) === '1') return undefined
+
+  const value = (await cookies()).get(guestCookieName(secure))?.value
+  return value === '' ? undefined : value
+}
+
+/**
+ * The same reader, one row.
+ *
+ * Only reached when there is no usable member session, which is what keeps a
+ * logged-in member from being counted twice — and signing in drops the guest
+ * row outright, so the two never overlap.
+ */
+async function touchGuestLocation(
+  guestToken: string | undefined,
+  location: BoardLocation,
+): Promise<void> {
+  if (guestToken === undefined || guestToken === '') return
+
+  const repo = presenceRepository()
+  if (repo === null) return
+
+  const now = new Date()
+  await repo.touchGuest({
+    tokenHash: createHash('sha256').update(guestToken).digest('hex'),
+    location: {
+      path: location.path,
+      forumId: location.forumId,
+      threadId: location.threadId,
+    },
+    now,
+    windowSeconds: LOCATION_WINDOW_SECONDS,
+    expiresAt: new Date(now.getTime() + GUEST_COOKIE_DAYS * 86_400_000),
+  })
+}
+
+/**
+ * Retires the guest identity of somebody who has just become a member.
+ *
+ * Called wherever a session cookie is set, rather than only at the login form,
+ * because that is every route into being signed in — the form, the remember-me
+ * resume, and a password change that reissues the session.
+ */
+export async function retireGuestPresence(): Promise<void> {
+  try {
+    const secure = env.NODE_ENV !== 'development'
+    const jar = await cookies()
+    const token = jar.get(guestCookieName(secure))?.value
+
+    if (token !== undefined && token !== '') {
+      await presenceRepository()?.dropGuest(createHash('sha256').update(token).digest('hex'))
+    }
+
+    jar.set(guestCookieName(secure), '', clearedCookie(secure))
+  } catch {
+    /* ignore */
+  }
+}
+
+export async function onlineScopeFor(actor: Actor): Promise<OnlineScope> {
+  const { authorizer } = getContainer()
+  const staff = actor.global.isAdministrator === true || actor.global.isSuperModerator === true
+
+  return {
+    ...(await authorizer.threadAudience(actor)),
+    content: contentScopeFrom({ seesUnapproved: staff, seesDeleted: staff }),
+    seesInvisible: await authorizer.can(actor, 'modcp.access'),
+  }
+}
+
+export async function readOnline(actor: Actor, now: Date): Promise<OnlineSnapshot | null> {
+  const repo = presenceRepository()
+  if (repo === null) return null
+
+  try {
+    return await repo.onlineNow(now, await onlineScopeFor(actor))
+  } catch {
+    return null
+  }
+}

package/src/server/profile-fields.ts

@@ -0,0 +1,112 @@
+import 'server-only'
+
+import { cache } from 'react'
+
+import { maxLengthFor, type ProfileFieldContext, ProfileFieldService } from '@meith/profile-fields'
+
+import { AUTH_CONFIG } from './auth-config'
+import { getContainer } from './container'
+import { getActor } from './context'
+
+export const FIELD_PREFIX = 'field:'
+
+export function submittedFields(form: FormData): ReadonlyMap<string, string> {
+  const submitted = new Map<string, string>()
+  for (const [name, value] of form.entries()) {
+    if (name.startsWith(FIELD_PREFIX) && typeof value === 'string') {
+      submitted.set(name.slice(FIELD_PREFIX.length), value)
+    }
+  }
+  return submitted
+}
+
+export function profileFieldService(): ProfileFieldService | null {
+  const { profileFields } = getContainer()
+  return profileFields === null ? null : new ProfileFieldService({ fields: profileFields })
+}
+
+export const viewerFieldContext = cache(async (): Promise<ProfileFieldContext | null> => {
+  const service = profileFieldService()
+  if (service === null) return null
+
+  const { authorizer } = getContainer()
+  const actor = await getActor()
+
+  const rules = await service.listGroupRules()
+  return { applicable: authorizer.applicableGroupRows(actor, rules) }
+})
+
+export async function registrationFieldContext(): Promise<ProfileFieldContext | null> {
+  const service = profileFieldService()
+  if (service === null) return null
+
+  const { authorizer } = getContainer()
+  const rules = await service.listGroupRules()
+
+  return {
+    applicable: authorizer.applicableGroupRowsForGroups([AUTH_CONFIG.defaultMemberGroupId], rules),
+  }
+}
+
+export async function registrationFields(): Promise<
+  readonly {
+    key: string
+    label: string
+    description: string | null
+    type: string | null
+    options: readonly string[]
+    maxLength: number
+  }[]
+> {
+  const service = profileFieldService()
+  if (service === null) return []
+
+  try {
+    const context = await registrationFieldContext()
+    if (context === null) return []
+
+    const fields = await service.requiredAtRegistration(context)
+    return fields.map((field) => ({
+      key: field.key,
+      label: field.label,
+      description: field.description,
+      type: field.type,
+      options: field.options,
+      maxLength: maxLengthFor(field),
+    }))
+  } catch {
+    return []
+  }
+}
+
+export async function visibleProfileFields(
+  ownerUserId: number,
+): Promise<readonly { label: string; value: string }[]> {
+  const service = profileFieldService()
+  const context = await viewerFieldContext()
+  if (service === null || context === null) return []
+
+  try {
+    const resolved = await service.visibleFor(ownerUserId, context)
+    return resolved.map((entry) => ({ label: entry.field.label, value: entry.value }))
+  } catch {
+    return []
+  }
+}
+
+export async function postbitProfileFields(
+  authorUserId: number,
+): Promise<readonly { label: string; value: string }[]> {
+  const service = profileFieldService()
+  const context = await viewerFieldContext()
+  if (service === null || context === null) return []
+
+  try {
+    const resolved = await service.visibleFor(authorUserId, context)
+    return resolved
+      .filter((entry) => entry.field.showInPostbit)
+      .map((entry) => ({ label: entry.field.label, value: entry.value }))
+  } catch {
+    return []
+  }
+}

package/src/server/push-actions.ts

@@ -0,0 +1,113 @@
+'use server'
+
+import { ForbiddenError, ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+import type { NotificationService } from '@meith/notifications'
+
+import type { FormState } from './auth-form-state'
+import { getActor } from './context'
+import { formStateReporter } from './form-state-reporter'
+import { tr } from './i18n'
+import { notificationService } from './notifications'
+import { pushAvailability } from './push'
+
+const toFormState = formStateReporter('push-actions', 'unexpected error in web push')
+
+const ENDPOINT_MAX = 1000
+
+const BASE64URL = /^[A-Za-z0-9_-]+$/
+
+const IP_LITERAL = /^\[|^\d+\.\d+\.\d+\.\d+$/
+
+const PRIVATE_SUFFIX = /\.(?:local|internal|localdomain|home|lan)$/
+
+export interface PushSubscriptionInput {
+  readonly endpoint: string
+  readonly p256dh: string
+  readonly auth: string
+}
+
+function keyBytes(value: string): number {
+  return BASE64URL.test(value) ? Buffer.from(value, 'base64url').length : 0
+}
+
+function isUsableEndpoint(endpoint: string): boolean {
+  if (endpoint.length === 0 || endpoint.length > ENDPOINT_MAX) return false
+
+  try {
+    const url = new URL(endpoint)
+    if (url.protocol !== 'https:') return false
+
+    const host = url.hostname.toLowerCase()
+    return (
+      host.includes('.') &&
+      !IP_LITERAL.test(host) &&
+      !PRIVATE_SUFFIX.test(host) &&
+      host !== 'localhost'
+    )
+  } catch {
+    return false
+  }
+}
+
+async function requirePushCentre(): Promise<{ service: NotificationService; userId: number }> {
+  const actor = await getActor()
+  if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+
+  const service = notificationService()
+  if (service === null) {
+    throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-16'))
+  }
+
+  if (!(await pushAvailability()).enabled) {
+    throw new ValidationError(msg('notice.app.board-offering-web-push'))
+  }
+
+  return { service, userId: actor.userId }
+}
+
+export async function subscribeToPushAction(input: PushSubscriptionInput): Promise<FormState> {
+  try {
+    if (
+      !isUsableEndpoint(input.endpoint) ||
+      keyBytes(input.p256dh) !== 65 ||
+      keyBytes(input.auth) !== 16
+    ) {
+      return { error: await tr('notice.app.push-subscription-valid') }
+    }
+
+    const { service, userId } = await requirePushCentre()
+    await service.subscribeToPush({
+      userId,
+      endpoint: input.endpoint,
+      p256dh: input.p256dh,
+      auth: input.auth,
+    })
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  return { notice: await tr('notice.pushSubscribed') }
+}
+
+export async function unsubscribeFromPushAction(endpoint: string): Promise<FormState> {
+  try {
+    const actor = await getActor()
+    if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+
+    const service = notificationService()
+    if (service === null) {
+      throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-16'))
+    }
+
+    if (!isUsableEndpoint(endpoint)) {
+      return { error: await tr('notice.app.push-subscription-valid') }
+    }
+
+    await service.unsubscribeFromPush(actor.userId, endpoint)
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  return { notice: await tr('notice.pushUnsubscribed') }
+}

package/src/server/push.ts

@@ -0,0 +1,40 @@
+import 'server-only'
+
+import { env } from '@meith/core'
+import { isVapidPublicKey } from '@meith/notifications'
+import { type PushProblem, resolvePushConfig } from '@meith/settings'
+
+import { getSettings } from './settings'
+
+export interface PushAvailability {
+  readonly enabled: boolean
+  readonly publicKey: string
+}
+
+const OFF: PushAvailability = { enabled: false, publicKey: '' }
+
+export interface PushReadiness {
+  readonly live: boolean
+  readonly problem: PushProblem | 'bad-key' | null
+}
+
+export async function pushAvailability(): Promise<PushAvailability> {
+  try {
+    const { config } = resolvePushConfig({ environment: env, settings: await getSettings() })
+    if (config === null || !isVapidPublicKey(config.publicKey)) return OFF
+    return { enabled: true, publicKey: config.publicKey }
+  } catch {
+    return OFF
+  }
+}
+
+export async function pushReadiness(): Promise<PushReadiness> {
+  const { config, problem } = resolvePushConfig({
+    environment: env,
+    settings: await getSettings(),
+  })
+
+  if (config === null) return { live: false, problem }
+  if (!isVapidPublicKey(config.publicKey)) return { live: false, problem: 'bad-key' }
+  return { live: true, problem: null }
+}

package/src/server/redirect-back.ts

@@ -0,0 +1,15 @@
+import 'server-only'
+
+import { headers } from 'next/headers'
+import { redirect } from 'next/navigation'
+
+import { PATH_HEADER } from './location-header'
+import { isSafeLocalPath } from './safe-path'
+
+export async function redirectToCurrentPath(): Promise<void> {
+  const path = (await headers()).get(PATH_HEADER)
+
+  if (typeof path === 'string' && isSafeLocalPath(path)) {
+    redirect(path)
+  }
+}

package/src/server/registration.ts

@@ -0,0 +1,7 @@
+import 'server-only'
+
+import { boardAuthConfig } from './auth-config'
+
+export async function registrationOpen(): Promise<boolean> {
+  return (await boardAuthConfig()).registrationEnabled
+}