@meith/web 0.16.0

package/src/server/user-admin.ts

@@ -0,0 +1,165 @@
+import { msg } from '@meith/i18n'
+import 'server-only'
+
+import type { BanRecord } from '@meith/accounts'
+import { BanService } from '@meith/accounts'
+import { ForbiddenError, optional } from '@meith/core'
+import {
+  type AccountState,
+  getDb,
+  PostgresBanRepository,
+  PostgresUserAdminRepository,
+  PostgresUserBulkRepository,
+  PostgresUserMergeRepository,
+  type PruneCriteria,
+  type UserDetail,
+  type UserSearchFilter,
+  type UserSearchRow,
+} from '@meith/db'
+import { SEED_GROUP } from '@meith/runtime'
+
+import { offsetOf, readPage } from '@/view/pager'
+
+import { getContainer } from './container'
+
+export const USER_PAGE = 50
+
+export function userAdminRepository(): PostgresUserAdminRepository | null {
+  return getContainer().dataSource === 'postgres' ? new PostgresUserAdminRepository(getDb()) : null
+}
+
+export function requireUserAdmin(): PostgresUserAdminRepository {
+  const repository = userAdminRepository()
+  if (repository === null) {
+    throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-2'))
+  }
+  return repository
+}
+
+export function banService(): BanService {
+  if (getContainer().dataSource !== 'postgres') {
+    throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-3'))
+  }
+  return new BanService({
+    bans: new PostgresBanRepository(getDb()),
+    bannedGroupId: SEED_GROUP.banned,
+  })
+}
+
+export function requireUserMerge(): PostgresUserMergeRepository {
+  if (getContainer().dataSource !== 'postgres') {
+    throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-4'))
+  }
+  return new PostgresUserMergeRepository(getDb())
+}
+
+export function banRepository(): PostgresBanRepository | null {
+  return getContainer().dataSource === 'postgres' ? new PostgresBanRepository(getDb()) : null
+}
+
+export function parseUserFilter(
+  params: Record<string, string | string[] | undefined>,
+): UserSearchFilter {
+  const one = (key: string): string | undefined => {
+    const value = params[key]
+    const text = Array.isArray(value) ? value[0] : value
+    return text === undefined || text.trim() === '' ? undefined : text.trim()
+  }
+
+  const number = (key: string): number | undefined => {
+    const raw = one(key)
+    if (raw === undefined) return undefined
+    const parsed = Number(raw)
+    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : undefined
+  }
+
+  const date = (key: string): Date | undefined => {
+    const raw = one(key)
+    if (raw === undefined) return undefined
+    const parsed = new Date(raw)
+    return Number.isNaN(parsed.getTime()) ? undefined : parsed
+  }
+
+  const state = one('state')
+  const stateFilter: AccountState | undefined =
+    state === 'active' || state === 'awaiting_activation' || state === 'banned' ? state : undefined
+
+  return {
+    ...optional(one('username'), (username) => ({ username })),
+    ...optional(one('email'), (email) => ({ email })),
+    ...optional(one('ip'), (ipPrefix) => ({ ipPrefix })),
+    ...optional(number('group'), (primaryGroupId) => ({ primaryGroupId })),
+    ...optional(stateFilter, (state) => ({ state })),
+    ...optional(date('after'), (registeredAfter) => ({ registeredAfter })),
+    ...optional(date('before'), (registeredBefore) => ({ registeredBefore })),
+    ...optional(number('minPosts'), (minPostCount) => ({ minPostCount })),
+    ...optional(number('maxPosts'), (maxPostCount) => ({ maxPostCount })),
+    ...optional(one('deleted'), () => ({ includeDeleted: true })),
+    offset: offsetOf(readPage(params), USER_PAGE),
+    limit: USER_PAGE,
+  }
+}
+
+export interface MemberView {
+  readonly member: UserDetail
+  readonly secondaryGroupIds: readonly number[]
+  readonly groups: readonly { readonly id: number; readonly title: string }[]
+  readonly activeBan: BanRecord | null
+  readonly sharedNetwork: readonly UserSearchRow[]
+}
+
+export async function buildMemberView(userId: number): Promise<MemberView | null> {
+  const repository = userAdminRepository()
+  const bans = banRepository()
+  if (repository === null || bans === null) return null
+
+  const member = await repository.readDetail(userId)
+  if (member === null) return null
+
+  const prefix = member.lastIpPrefix ?? member.registrationIpPrefix ?? ''
+
+  return {
+    member,
+    secondaryGroupIds: await repository.readSecondaryGroups(userId),
+    groups: await repository.listGroups(),
+    activeBan: await bans.findActive(userId),
+    sharedNetwork: await repository.sharingIpPrefix(prefix, userId),
+  }
+}
+
+export function requireUserBulk(): PostgresUserBulkRepository {
+  if (getContainer().dataSource !== 'postgres') {
+    throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-5'))
+  }
+  return new PostgresUserBulkRepository(getDb())
+}
+
+export function userBulkRepository(): PostgresUserBulkRepository | null {
+  return getContainer().dataSource === 'postgres' ? new PostgresUserBulkRepository(getDb()) : null
+}
+
+export function parsePruneCriteria(
+  params: Record<string, string | string[] | undefined>,
+): PruneCriteria | null {
+  const one = (key: string): string | undefined => {
+    const value = params[key]
+    const text = Array.isArray(value) ? value[0] : value
+    return text === undefined || text.trim() === '' ? undefined : text.trim()
+  }
+
+  const date = (key: string): Date | undefined => {
+    const raw = one(key)
+    if (raw === undefined) return undefined
+    const parsed = new Date(raw)
+    return Number.isNaN(parsed.getTime()) ? undefined : parsed
+  }
+
+  const registeredBefore = date('before')
+  if (registeredBefore === undefined) return null
+
+  return {
+    registeredBefore,
+    ...optional(date('inactive'), (inactiveSince) => ({ inactiveSince })),
+    ...optional(one('awaiting'), () => ({ onlyAwaitingActivation: true })),
+  }
+}

package/src/server/usercp-actions.ts

@@ -0,0 +1,263 @@
+'use server'
+
+import { redirect } from 'next/navigation'
+
+import { MemberSettingsService } from '@meith/accounts'
+import { ForbiddenError, ValidationError } from '@meith/core'
+import { currentRequestId } from '@meith/core/logger'
+import { drivers } from '@meith/drivers'
+import { msg } from '@meith/i18n'
+import { prepareSignature } from '@meith/signatures'
+
+import { adminService } from './admin'
+import { limitMessage, spendLimit } from './antispam'
+import { boardAuthConfig } from './auth-config'
+import { recordAuthEvent } from './auth-events'
+import type { FormState } from './auth-form-state'
+import { AVATAR_FIELD, canUploadAvatar, requireAvatarService } from './avatars'
+import { configuredSessions, getContainer } from './container'
+import { getActor } from './context'
+import { assertDemoAccountChangeable } from './demo'
+import { formStateReporter } from './form-state-reporter'
+import { text } from './form-values'
+import { getTranslator, tr } from './i18n'
+import { boardRendering } from './markdown-pipeline'
+import { emitEvent } from './plugin-view'
+import { profileFieldService, submittedFields, viewerFieldContext } from './profile-fields'
+import { setSessionCookie } from './session-cookies'
+import { signatureStore, viewerSignatureLimits } from './signatures'
+import { sendEmailChangeConfirmation, sendEmailChangeNotice } from './usercp-mail'
+
+const toFormState = formStateReporter('usercp-actions', 'unexpected error in the UserCP')
+
+async function requireOwnSettings(): Promise<{
+  service: MemberSettingsService
+  userId: number
+}> {
+  const actor = await getActor()
+  if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+
+  const { memberSettings, accountStore } = getContainer()
+  if (memberSettings === null || accountStore === null) {
+    throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-9'))
+  }
+
+  return {
+    service: new MemberSettingsService({
+      settings: memberSettings,
+      accounts: accountStore.accounts,
+      sessions: accountStore.sessions,
+      remember: accountStore.remember,
+      tokens: accountStore.tokens,
+    }),
+    userId: actor.userId,
+  }
+}
+
+export async function saveProfileAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    const { service, userId } = await requireOwnSettings()
+    await service.saveProfile({
+      userId,
+      location: text(form, 'location'),
+      website: text(form, 'website'),
+      bio: text(form, 'bio'),
+    })
+
+    const fields = profileFieldService()
+    const context = await viewerFieldContext()
+    if (fields !== null && context !== null) {
+      await fields.save({ userId, submitted: submittedFields(form), context })
+    }
+
+    await emitEvent(
+      'user.profile.updated',
+      { userId, fields: ['location', 'website', 'bio'] },
+      { requestId: currentRequestId() ?? null },
+    )
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/usercp/profile?saved=1')
+}
+
+export async function saveDisplayGroupAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    const { service, userId } = await requireOwnSettings()
+    await service.saveDisplayGroup({ userId, displayGroupId: text(form, 'displayGroupId') })
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/usercp/profile?saved=1')
+}
+
+export async function saveOptionsAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    const { service, userId } = await requireOwnSettings()
+    await service.saveOptions({
+      userId,
+      timezone: text(form, 'timezone'),
+      locale: text(form, 'locale'),
+      postsPerPage: text(form, 'postsPerPage'),
+      threadsPerPage: text(form, 'threadsPerPage'),
+      invisible: form.get('invisible') !== null,
+    })
+
+    await emitEvent(
+      'user.profile.updated',
+      { userId, fields: ['timezone', 'locale', 'postsPerPage', 'threadsPerPage', 'invisible'] },
+      { requestId: currentRequestId() ?? null },
+    )
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/usercp/options?saved=1')
+}
+
+export async function changePasswordAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    const { service, userId } = await requireOwnSettings()
+
+    await assertDemoAccountChangeable(userId, 'password')
+
+    const next = text(form, 'newPassword')
+    if (next !== text(form, 'confirmPassword')) {
+      return { error: await tr('notice.app.two-new-passwords-match') }
+    }
+
+    await service.changePassword({
+      userId,
+      currentPassword: text(form, 'currentPassword'),
+      newPassword: next,
+      minLength: (await boardAuthConfig()).minPasswordLength,
+    })
+
+    const session = await (await configuredSessions()).start(userId)
+    await setSessionCookie(session.token, session.expiresAt)
+
+    const admin = adminService()
+    if (admin !== null) await admin.endAllFor(userId)
+
+    await recordAuthEvent({ userId, kind: 'password_changed' })
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/usercp/security?changed=password')
+}
+
+export async function requestEmailChangeAction(
+  _prev: FormState,
+  form: FormData,
+): Promise<FormState> {
+  let pending: { token: string; email: string; previousEmail: string; userId: number }
+  try {
+    const { service, userId } = await requireOwnSettings()
+
+    await assertDemoAccountChangeable(userId, 'email')
+
+    pending = {
+      userId,
+      ...(await service.requestEmailChange({
+        userId,
+        currentPassword: text(form, 'currentPassword'),
+        newEmail: text(form, 'newEmail'),
+      })),
+    }
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  const t = await getTranslator()
+  await sendEmailChangeConfirmation({ ...pending, t }).catch(() => undefined)
+  await sendEmailChangeNotice({
+    stage: 'requested',
+    previousEmail: pending.previousEmail,
+    email: pending.email,
+    t,
+  })
+  await recordAuthEvent({ userId: pending.userId, kind: 'email_change_requested' })
+
+  redirect('/usercp/security?sent=1')
+}
+
+export async function saveSignatureAction(_prev: FormState, form: FormData): Promise<FormState> {
+  const values = { signature: text(form, 'signature') }
+
+  try {
+    const actor = await getActor()
+    if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+
+    const store = signatureStore()
+    if (store === null) {
+      throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-10'))
+    }
+
+    const limits = await viewerSignatureLimits()
+    const { source, rendered } = await prepareSignature(values.signature, limits, {
+      authorId: actor.userId,
+      rendering: boardRendering,
+    })
+
+    const wrote = await store.save({
+      userId: actor.userId,
+      signature: source,
+      signatureHtml: rendered.html,
+      renderVersion: rendered.version,
+    })
+
+    if (!wrote) {
+      throw new ForbiddenError(msg('error.app.signature-locked-by-moderator-so'))
+    }
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/usercp/signature?saved=1')
+}
+
+export async function saveAvatarAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    const actor = await getActor()
+    const service = requireAvatarService(actor)
+
+    const file = form.get(AVATAR_FIELD)
+    if (!(file instanceof File) || file.size === 0) {
+      throw new ValidationError(msg('error.app.choose-image-first'))
+    }
+
+    const limited = await spendLimit({ scope: 'upload', actor })
+    if (limited !== null && !limited.allowed) throw new ValidationError(limitMessage(limited))
+
+    await service.upload({
+      userId: actor.userId as number,
+      file: { filename: file.name, bytes: new Uint8Array(await file.arrayBuffer()) },
+      mayUpload: canUploadAvatar(actor),
+    })
+
+    await drivers().queue.enqueue(
+      'avatars.process',
+      { userId: actor.userId },
+      { dedupeKey: `avatar:${actor.userId}:${Date.now()}` },
+    )
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/usercp/avatar?saved=processing')
+}
+
+export async function removeAvatarAction(_prev: FormState): Promise<FormState> {
+  try {
+    const actor = await getActor()
+    const service = requireAvatarService(actor)
+    await service.remove(actor.userId as number)
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/usercp/avatar?saved=removed')
+}

package/src/server/usercp-mail.ts

@@ -0,0 +1,120 @@
+import 'server-only'
+
+import { logger } from '@meith/core'
+import type { Translator } from '@meith/i18n'
+import { absoluteUrl, renderMail } from '@meith/mail'
+
+import { brandedFor } from './mail-brand'
+import { sendBoardMail } from './mail-send'
+
+const CONFIRM_PATH = '/usercp/email/confirm'
+const RESET_PATH = '/reset'
+
+export type EmailChangeStage = 'requested' | 'adopted'
+
+export async function sendEmailChangeConfirmation(input: {
+  readonly token: string
+  readonly email: string
+  readonly t: Translator
+}): Promise<void> {
+  const { t } = input
+  const { brand, boardName } = await brandedFor(t, 'usercpMail.boardFallback')
+
+  const link = absoluteUrl(
+    brand.boardUrl,
+    `${CONFIRM_PATH}?token=${encodeURIComponent(input.token)}`,
+  )
+
+  const mail = renderMail({
+    brand,
+    t,
+    body: {
+      title: t.t('usercpMail.subject'),
+      greeting: t.t('usercpMail.greeting'),
+      paragraphs: [
+        t.t('usercpMail.intro', { board: boardName }),
+        ...(link === null ? [t.t('usercpMail.noLink')] : []),
+        t.t('usercpMail.ignore'),
+      ],
+      ...(link === null ? {} : { action: { label: t.t('usercpMail.action'), href: link } }),
+      note: t.t('usercpMail.ttl'),
+      footer: [{ text: t.t('mail.footer.sentBy', { board: boardName }) }],
+    },
+  })
+
+  const fromName = brand.fromName ?? ''
+
+  try {
+    await sendBoardMail('usercp.email-change', {
+      to: input.email,
+      subject: mail.subject,
+      text: mail.text,
+      html: mail.html,
+      ...(fromName === '' ? {} : { fromName }),
+    })
+  } catch (err) {
+    logger({ module: 'usercp' }).error({ err }, 'could not send an e-mail change confirmation')
+    throw err
+  }
+}
+
+export async function sendEmailChangeNotice(input: {
+  readonly stage: EmailChangeStage
+  readonly previousEmail: string
+  readonly email: string
+  readonly t: Translator
+}): Promise<void> {
+  const { t } = input
+  const { brand, boardName } = await brandedFor(t, 'usercpMail.boardFallback')
+
+  const requested = input.stage === 'requested'
+  const link = absoluteUrl(brand.boardUrl, requested ? RESET_PATH : '/')
+
+  const secure = ((): string => {
+    if (!requested) return t.t('usercpMail.notice.adoptedSecure')
+    return t.t(
+      link === null
+        ? 'usercpMail.notice.requestedSecureNoLink'
+        : 'usercpMail.notice.requestedSecure',
+    )
+  })()
+
+  const action = requested
+    ? t.t('usercpMail.notice.requestedAction')
+    : t.t('usercpMail.notice.adoptedAction', { board: boardName })
+
+  const mail = renderMail({
+    brand,
+    t,
+    body: {
+      title: t.t(
+        requested ? 'usercpMail.notice.requestedSubject' : 'usercpMail.notice.adoptedSubject',
+      ),
+      greeting: t.t('usercpMail.greeting'),
+      paragraphs: [
+        t.t(requested ? 'usercpMail.notice.requested' : 'usercpMail.notice.adopted', {
+          board: boardName,
+          email: input.email,
+        }),
+        secure,
+      ],
+      ...(link === null ? {} : { action: { label: action, href: link } }),
+      note: t.t('usercpMail.notice.nothingToDo'),
+      footer: [{ text: t.t('mail.footer.sentBy', { board: boardName }) }],
+    },
+  })
+
+  const fromName = brand.fromName ?? ''
+
+  try {
+    await sendBoardMail('usercp.email-change', {
+      to: input.previousEmail,
+      subject: mail.subject,
+      text: mail.text,
+      html: mail.html,
+      ...(fromName === '' ? {} : { fromName }),
+    })
+  } catch (err) {
+    logger({ module: 'usercp' }).error({ err }, 'could not send an e-mail change notice')
+  }
+}

package/src/server/viewer-preferences.ts

@@ -0,0 +1,64 @@
+import 'server-only'
+
+import { cookies } from 'next/headers'
+import { cache } from 'react'
+
+import { resolveTimezone, TIMEZONE_COOKIE } from '@/view/timezone'
+
+import { getContainer } from './container'
+import { getActor } from './context'
+import { getSettings } from './settings'
+
+export interface ViewerPreferences {
+  readonly timezone: string
+  readonly timezoneIsAutomatic: boolean
+  readonly locale: string | null
+  readonly postsPerPage: number
+  readonly threadsPerPage: number
+}
+
+const detectedZone = cache(async (): Promise<string | null> => {
+  try {
+    return (await cookies()).get(TIMEZONE_COOKIE)?.value ?? null
+  } catch {
+    return null
+  }
+})
+
+export const getViewerPreferences = cache(async (): Promise<ViewerPreferences> => {
+  const detected = await detectedZone()
+
+  const settings = await getSettings()
+  const defaults = {
+    postsPerPage: settings.get('display.posts_per_page'),
+    threadsPerPage: settings.get('display.threads_per_page'),
+  }
+
+  const stored = await storedSettings()
+  const timezone = resolveTimezone({ stored: stored?.timezone ?? null, detected })
+
+  return {
+    timezone: timezone.zone,
+    timezoneIsAutomatic: timezone.isAutomatic,
+    locale: stored?.locale ?? null,
+    postsPerPage: stored?.postsPerPage ?? defaults.postsPerPage,
+    threadsPerPage: stored?.threadsPerPage ?? defaults.threadsPerPage,
+  }
+})
+
+async function storedSettings(): Promise<{
+  readonly timezone: string
+  readonly locale: string
+  readonly postsPerPage: number | null
+  readonly threadsPerPage: number | null
+} | null> {
+  const actor = await getActor()
+  const { memberSettings } = getContainer()
+  if (actor.userId === null || memberSettings === null) return null
+
+  try {
+    return await memberSettings.read(actor.userId)
+  } catch {
+    return null
+  }
+}