@meith/web 0.31.0 → 0.33.0

package/src/server/report-actions.ts

@@ -5,7 +5,7 @@ import { redirect } from 'next/navigation'
 import { ForbiddenError, ValidationError } from '@meith/core'
 import { currentRequestId } from '@meith/core/logger'
 import { msg } from '@meith/i18n'
-import { parseTargetKind, ReportService } from '@meith/moderation'
+import { parseReportCategory, parseTargetKind, ReportService } from '@meith/moderation'
 
 import { limitMessage, spendLimit } from './antispam'
 import type { FormState } from './auth-form-state'
@@ -17,6 +17,7 @@ import { tr } from './i18n'
 import { reportNotifier } from './notifications'
 import { emitEvent } from './plugin-view'
 import { resolveReportScope } from './report-scope'
+import { getSettings } from './settings'
 
 function field(form: FormData, name: string): string {
   const value = form.get(name)
@@ -29,12 +30,17 @@ export async function fileReportAction(_prev: FormState, form: FormData): Promis
   const kind = parseTargetKind(field(form, 'kind'))
   const targetId = positiveIntIn(field(form, 'targetId'))
   const reason = field(form, 'reason')
-  const values = { reason }
+  const category = parseReportCategory(field(form, 'category'))
+  const values = { reason, ...(category === null ? {} : { category }) }
 
   if (kind === null || targetId === null) {
     return { error: await tr('notice.app.exist'), values }
   }
 
+  if (category === null) {
+    return { error: await tr('notice.app.choose-report-category'), values }
+  }
+
   const { authorizer, reports } = getContainer()
   if (reports === null) {
     return {
@@ -72,11 +78,16 @@ export async function fileReportAction(_prev: FormState, form: FormData): Promis
       return { error: limitMessage(limited), values }
     }
 
+    const settings = await getSettings()
+    const flagThreshold = Number(settings.get('moderation.flag_threshold') ?? 0)
+
     const outcome = await new ReportService({ reports }).file({
       kind,
       targetId,
+      category,
       reason,
       reporterUserId: actor.userId,
+      flagThreshold,
     })
 
     if (!outcome.duplicate) {

package/src/server/reputation-actions.ts

@@ -7,13 +7,19 @@ import { msg } from '@meith/i18n'
 import { parseRating } from '@meith/reputation'
 
 import { postLink } from '@/view/post-link'
+import { isEnhancedSubmit } from '@/view/progressive-enhancement'
 
 import type { FormState } from './auth-form-state'
 import { getActor } from './context'
 import { formStateReporter } from './form-state-reporter'
 import { trimmedText } from './form-values'
 import { emitEvent, viewerRef } from './plugin-view'
-import { reputationService, reputationSettings, viewerRaterLimits } from './reputation'
+import {
+  reputationService,
+  reputationSettings,
+  thanksForPosts,
+  viewerRaterLimits,
+} from './reputation'
 import { requireRateablePost } from './reputation-target'
 import { isSafeLocalPath } from './safe-path'
 
@@ -138,6 +144,11 @@ export async function thankForPostAction(_prev: FormState, form: FormData): Prom
       })
       await announceReputation(service, userId, 1)
     }
+
+    if (isEnhancedSubmit(form)) {
+      const thanks = (await thanksForPosts([postId])).get(postId)
+      return { thanks: thanks ?? { thanked: false, count: 0 } }
+    }
   } catch (err) {
     return toFormState(err)
   }

package/src/server/search-page.ts

@@ -30,7 +30,13 @@ 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 {
+  requireSearch,
+  requireSearchEnabled,
+  searchLanguage,
+  searchMinWordLength,
+  searchScopeFor,
+} from './search'
 import { getSettings } from './settings'
 
 export const SEARCH_PAGE = 20
@@ -149,7 +155,7 @@ export async function openSearch(input: {
   const refine = trimRefinement(input.refine, filters)
   const effective = narrowFilters(filters, refine)
   const scope = await searchScopeFor(input.actor)
-  const provider = requireSearch()
+  const provider = requireSearch(await searchLanguage())
 
   const [results, summary] = await Promise.all([
     provider.search(

package/src/server/search.ts

@@ -3,7 +3,12 @@ import 'server-only'
 
 import type { Actor } from '@meith/authorization'
 import { contentScopeFrom, ForbiddenError } from '@meith/core'
-import { getDb, PostgresSearchRepository } from '@meith/db'
+import {
+  DEFAULT_SEARCH_CONFIG,
+  getDb,
+  PostgresSearchRepository,
+  resolveSearchConfig,
+} from '@meith/db'
 import type { SearchScope } from '@meith/search'
 
 import { getContainer } from './container'
@@ -21,12 +26,20 @@ 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 async function searchLanguage(): Promise<string> {
+  return resolveSearchConfig((await getSettings()).get('search.language'))
 }
 
-export function requireSearch(): PostgresSearchRepository {
-  const provider = searchProvider()
+export function searchProvider(
+  config: string = DEFAULT_SEARCH_CONFIG,
+): PostgresSearchRepository | null {
+  return getContainer().dataSource === 'postgres'
+    ? new PostgresSearchRepository(getDb(), config)
+    : null
+}
+
+export function requireSearch(config: string = DEFAULT_SEARCH_CONFIG): PostgresSearchRepository {
+  const provider = searchProvider(config)
   if (provider === null) {
     throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-11'))
   }

package/src/server/session-cookies.ts

@@ -6,8 +6,11 @@ import { env } from '@meith/core'
 
 import {
   ADMIN_COOKIE,
+  ADMIN_SECOND_FACTOR_COOKIE,
   adminCookie,
+  adminSecondFactorCookie,
   clearedAdminCookie,
+  clearedAdminSecondFactorCookie,
   clearedCookie,
   passkeyCookie,
   passkeyCookieName,
@@ -55,6 +58,21 @@ export async function readAdminToken(): Promise<string | null> {
   return jar.get(ADMIN_COOKIE)?.value ?? null
 }
 
+export async function setAdminSecondFactorCookie(token: string, expiresAt: Date): Promise<void> {
+  const jar = await cookies()
+  jar.set(ADMIN_SECOND_FACTOR_COOKIE, token, adminSecondFactorCookie(expiresAt, secure()))
+}
+
+export async function readAdminSecondFactorToken(): Promise<string | null> {
+  const jar = await cookies()
+  return jar.get(ADMIN_SECOND_FACTOR_COOKIE)?.value ?? null
+}
+
+export async function clearAdminSecondFactorCookie(): Promise<void> {
+  const jar = await cookies()
+  jar.set(ADMIN_SECOND_FACTOR_COOKIE, '', clearedAdminSecondFactorCookie(secure()))
+}
+
 export async function clearSessionCookies(): Promise<void> {
   const jar = await cookies()
   const isSecure = secure()

package/src/server/subscription-actions.ts

@@ -12,6 +12,8 @@ import {
   type UnsubscribeScope,
 } from '@meith/subscriptions'
 
+import { isEnhancedSubmit } from '@/view/progressive-enhancement'
+
 import type { FormState } from './auth-form-state'
 import { getContainer } from './container'
 import { getActor } from './context'
@@ -72,6 +74,8 @@ export async function subscribeAction(_prev: FormState, form: FormData): Promise
       { userId: actor.userId, target, targetId, subscribed: true },
       { requestId: currentRequestId() ?? null },
     )
+
+    if (isEnhancedSubmit(form)) return { subscribed: true }
   } catch (err) {
     return toFormState(err)
   }
@@ -106,6 +110,8 @@ export async function unsubscribeAction(_prev: FormState, form: FormData): Promi
       { userId: actor.userId, target, targetId, subscribed: false },
       { requestId: currentRequestId() ?? null },
     )
+
+    if (isEnhancedSubmit(form)) return { subscribed: false }
   } catch (err) {
     return toFormState(err)
   }
@@ -144,6 +150,8 @@ export async function unsubscribeByTokenAction(
           ['subscription.digest', false],
         ]),
       )
+    } else if (claim.scope === 'board-digest') {
+      await notifications.savePreferences(claim.userId, 'email', new Map([['board.digest', false]]))
     } else {
       await new SubscriptionService({ subscriptions }).unsubscribe({
         userId: claim.userId,
@@ -160,6 +168,7 @@ export async function unsubscribeByTokenAction(
 
 function doneFor(scope: UnsubscribeScope): string {
   if (scope === 'mass-mail') return 'announcements'
+  if (scope === 'board-digest') return 'boardDigest'
   return scope === 'email' ? 'email' : 'one'
 }
 

package/src/server/thread-core.ts

@@ -4,7 +4,12 @@ import type { Actor } from '@meith/authorization'
 import { ForbiddenError, type ForumPermissions, ValidationError } from '@meith/core'
 import { msg } from '@meith/i18n'
 import { restrictsPosting } from '@meith/moderation'
-import { type AuthorRestriction, type ForumPostingTarget, ThreadComposer } from '@meith/threads'
+import {
+  type AuthorRestriction,
+  type ForumPostingTarget,
+  type SubscriptionCadence,
+  ThreadComposer,
+} from '@meith/threads'
 
 import {
   dailyLimitMessage,
@@ -58,10 +63,12 @@ export interface SubmitThreadInput {
   readonly message: string
   readonly prefixId?: number | null
   readonly subscribe?: boolean
+  readonly subscribeMode?: SubscriptionCadence
   readonly poll?:
     | {
         readonly question: string
         readonly options: readonly string[]
+        readonly closesAt?: Date | null
         readonly maxOptions?: number
         readonly allowRevote?: boolean
         readonly publicVotes?: boolean
@@ -126,6 +133,7 @@ export async function submitThread(
       message: draft.body,
       prefixId: draft.prefixId,
       subscribe: input.subscribe ?? false,
+      ...(input.subscribeMode === undefined ? {} : { subscribeMode: input.subscribeMode }),
       heldAsNewMember: await holdsNewMember({
         actor,
         postCount: profile.postCount,
@@ -139,7 +147,7 @@ export async function submitThread(
             poll: {
               question: input.poll.question,
               options: input.poll.options,
-              closesAt: null,
+              closesAt: input.poll.closesAt ?? null,
               ...(input.poll.maxOptions === undefined ? {} : { maxOptions: input.poll.maxOptions }),
               ...(input.poll.allowRevote === undefined
                 ? {}

package/src/server/thread-tool-actions.ts

@@ -8,6 +8,7 @@ import { msg } from '@meith/i18n'
 import { parseThreadTool, type ThreadToolRights, ThreadTools } from '@meith/moderation'
 
 import type { FormState } from './auth-form-state'
+import { requireConfirmation } from './confirm'
 import { getContainer } from './container'
 import { getActor } from './context'
 import { formStateReporter } from './form-state-reporter'
@@ -63,6 +64,11 @@ export async function threadToolAction(_prev: FormState, form: FormData): Promis
         ? await resolveRights(toForumId, threadAuthorId)
         : undefined
 
+    if (tool === 'delete' && rights.delete) {
+      const confirm = requireConfirmation(form, await tr('moderationForm.confirm.deleteThread'))
+      if (confirm !== null) return confirm
+    }
+
     outcome = await new ThreadTools({ threads: threadTools }).apply({
       threadId,
       tool,

package/src/server/unread-goto.ts

@@ -0,0 +1,28 @@
+import 'server-only'
+
+import type { ContentScope } from '@meith/core'
+import type { PostLocation, PostRepository } from '@meith/posts'
+import type { ReadStateRepository } from '@meith/threads'
+
+export interface UnreadGotoThread {
+  readonly id: number
+  readonly forumId: number
+  readonly lastPostId: number | null
+}
+
+export async function resolveUnreadGoto(
+  posts: PostRepository,
+  readState: ReadStateRepository,
+  userId: number,
+  thread: UnreadGotoThread,
+  options: { readonly scope: ContentScope; readonly pageSize: number },
+): Promise<PostLocation | null> {
+  const marker = await readState.markerFor(userId, thread.id, thread.forumId)
+  const located = await posts.locateFirstUnread(
+    thread.id,
+    { postId: marker.lastReadPostId ?? 0, since: marker.forumReadAt },
+    options,
+  )
+  if (located !== null) return located
+  return thread.lastPostId === null ? null : posts.locate(thread.id, thread.lastPostId, options)
+}

package/src/server/upgrade-notice.ts

@@ -16,7 +16,7 @@ import { planUpgrade, type UpgradeState, upgradeNotice } from '@meith/upgrade'
 
 import { activeDefinitions } from './plugin-host'
 
-export const CODE_VERSION = '0.31.0'
+export const CODE_VERSION = '0.33.0'
 
 export interface UpgradeApplied {
   readonly plugins: readonly string[]

package/src/server/usercp-actions.ts

@@ -18,6 +18,7 @@ import { AVATAR_FIELD, canUploadAvatar, requireAvatarService } from './avatars'
 import { configuredSessions, getContainer } from './container'
 import { getActor } from './context'
 import { assertDemoAccountChangeable } from './demo'
+import { revokeFeedToken } from './feed-token'
 import { formStateReporter } from './form-state-reporter'
 import { text } from './form-values'
 import { getTranslator, tr } from './i18n'
@@ -103,11 +104,24 @@ export async function saveOptionsAction(_prev: FormState, form: FormData): Promi
       postsPerPage: text(form, 'postsPerPage'),
       threadsPerPage: text(form, 'threadsPerPage'),
       invisible: form.get('invisible') !== null,
+      autoWatchOwnThreads: text(form, 'autoWatchOwnThreads'),
+      autoWatchRepliedThreads: text(form, 'autoWatchRepliedThreads'),
     })
 
     await emitEvent(
       'user.profile.updated',
-      { userId, fields: ['timezone', 'locale', 'postsPerPage', 'threadsPerPage', 'invisible'] },
+      {
+        userId,
+        fields: [
+          'timezone',
+          'locale',
+          'postsPerPage',
+          'threadsPerPage',
+          'invisible',
+          'autoWatchOwnThreads',
+          'autoWatchRepliedThreads',
+        ],
+      },
       { requestId: currentRequestId() ?? null },
     )
   } catch (err) {
@@ -117,6 +131,20 @@ export async function saveOptionsAction(_prev: FormState, form: FormData): Promi
   redirect('/usercp/options?saved=1')
 }
 
+export async function saveBoardDigestCadenceAction(
+  _prev: FormState,
+  form: FormData,
+): Promise<FormState> {
+  try {
+    const { service, userId } = await requireOwnSettings()
+    await service.saveBoardDigestCadence({ userId, cadence: text(form, 'cadence') })
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/notifications/preferences?saved=digest-cadence')
+}
+
 export async function changePasswordAction(_prev: FormState, form: FormData): Promise<FormState> {
   try {
     const { service, userId } = await requireOwnSettings()
@@ -141,6 +169,8 @@ export async function changePasswordAction(_prev: FormState, form: FormData): Pr
     const admin = adminService()
     if (admin !== null) await admin.endAllFor(userId)
 
+    await revokeFeedToken(userId)
+
     await recordAuthEvent({ userId, kind: 'password_changed' })
   } catch (err) {
     return toFormState(err)

package/src/server/viewer-preferences.ts

@@ -3,6 +3,8 @@ import 'server-only'
 import { cookies } from 'next/headers'
 import { cache } from 'react'
 
+import type { SubscriptionMode } from '@meith/subscriptions'
+
 import { resolveTimezone, TIMEZONE_COOKIE } from '@/view/timezone'
 
 import { getContainer } from './container'
@@ -15,6 +17,7 @@ export interface ViewerPreferences {
   readonly locale: string | null
   readonly postsPerPage: number
   readonly threadsPerPage: number
+  readonly autoWatchRepliedThreads: SubscriptionMode
 }
 
 const detectedZone = cache(async (): Promise<string | null> => {
@@ -43,6 +46,7 @@ export const getViewerPreferences = cache(async (): Promise<ViewerPreferences> =
     locale: stored?.locale ?? null,
     postsPerPage: stored?.postsPerPage ?? defaults.postsPerPage,
     threadsPerPage: stored?.threadsPerPage ?? defaults.threadsPerPage,
+    autoWatchRepliedThreads: stored?.autoWatchRepliedThreads ?? 'none',
   }
 })
 
@@ -51,6 +55,7 @@ async function storedSettings(): Promise<{
   readonly locale: string
   readonly postsPerPage: number | null
   readonly threadsPerPage: number | null
+  readonly autoWatchRepliedThreads: SubscriptionMode
 } | null> {
   const actor = await getActor()
   const { memberSettings } = getContainer()

package/src/server/webhook-actions.ts

@@ -0,0 +1,98 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+
+import { isAppError, logger, publicMessageOf } from '@meith/core'
+
+import { recordAdminAction, requireAdmin, requireFreshAdmin } from './admin'
+import type { FormState } from './auth-form-state'
+import { getMessageResolver, tr } from './i18n'
+import { createWebhook, webhookStore } from './webhooks-admin'
+
+function field(form: FormData, name: string): string {
+  const value = form.get(name)
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function refreshWebhookList(): void {
+  revalidatePath('/admin/webhooks')
+}
+
+async function toState(err: unknown): Promise<FormState> {
+  if (isAppError(err)) return { error: publicMessageOf(err, await getMessageResolver()) }
+  logger({ module: 'webhook-actions' }).error({ err }, 'webhook action failed')
+  return { error: await tr('notice.app.something-went-wrong-please-try') }
+}
+
+export async function createWebhookAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    const admin = await requireFreshAdmin()
+
+    const secret = await createWebhook({
+      url: field(form, 'url'),
+      topics: form.getAll('topics').filter((value): value is string => typeof value === 'string'),
+      format: field(form, 'format'),
+      active: field(form, 'active') !== 'false',
+      createdBy: admin.userId,
+    })
+
+    await recordAdminAction({
+      action: 'system.webhook_created',
+      detail: { url: field(form, 'url') },
+    })
+
+    refreshWebhookList()
+
+    return { notice: 'created', values: { secret } }
+  } catch (err) {
+    return toState(err)
+  }
+}
+
+export async function deleteWebhookAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const id = Number(field(form, 'webhookId'))
+    if (!Number.isSafeInteger(id) || id <= 0) return { error: await tr('notice.app.such-webhook') }
+
+    const store = webhookStore()
+    if (store === null) return { error: await tr('notice.app.board-database-webhooks') }
+
+    const removed = await store.remove(id)
+    if (removed) {
+      await recordAdminAction({ action: 'system.webhook_deleted', detail: { webhookId: id } })
+    }
+
+    refreshWebhookList()
+    return { notice: 'deleted' }
+  } catch (err) {
+    return toState(err)
+  }
+}
+
+export async function toggleWebhookAction(_prev: FormState, form: FormData): Promise<FormState> {
+  try {
+    await requireAdmin()
+
+    const id = Number(field(form, 'webhookId'))
+    if (!Number.isSafeInteger(id) || id <= 0) return { error: await tr('notice.app.such-webhook') }
+
+    const store = webhookStore()
+    if (store === null) return { error: await tr('notice.app.board-database-webhooks') }
+
+    const active = field(form, 'active') === 'true'
+    const changed = await store.setActive(id, active)
+    if (changed) {
+      await recordAdminAction({
+        action: 'system.webhook_updated',
+        detail: { webhookId: id, active },
+      })
+    }
+
+    refreshWebhookList()
+    return { notice: 'updated' }
+  } catch (err) {
+    return toState(err)
+  }
+}

package/src/server/webhooks-admin.ts

@@ -0,0 +1,122 @@
+import { msg } from '@meith/i18n'
+import 'server-only'
+
+import {
+  generateWebhookSecret,
+  isWebhookFormat,
+  isWebhookTopic,
+  WEBHOOK_FORMATS,
+  WEBHOOK_TOPICS,
+  type WebhookFormat,
+  type WebhookTopic,
+} from '@meith/api'
+import { ValidationError } from '@meith/core'
+import { getDb, PostgresWebhookRepository } from '@meith/db'
+
+import { getContainer } from './container'
+
+export function webhookStore(): PostgresWebhookRepository | null {
+  return getContainer().dataSource === 'postgres' ? new PostgresWebhookRepository(getDb()) : null
+}
+
+export interface WebhookDeliveryLogEntry {
+  readonly id: number
+  readonly deliveryId: string
+  readonly topic: string
+  readonly status: string
+  readonly attempts: number
+  readonly lastStatusCode: number | null
+  readonly lastError: string | null
+  readonly createdAt: Date
+  readonly completedAt: Date | null
+}
+
+export interface WebhookRow {
+  readonly id: number
+  readonly url: string
+  readonly topics: readonly WebhookTopic[]
+  readonly active: boolean
+  readonly format: WebhookFormat
+  readonly createdAt: Date
+  readonly delivered: number
+  readonly pending: number
+  readonly dead: number
+  readonly recent: readonly WebhookDeliveryLogEntry[]
+}
+
+export interface WebhookView {
+  readonly subscriptions: readonly WebhookRow[]
+  readonly topics: readonly WebhookTopic[]
+  readonly formats: readonly WebhookFormat[]
+}
+
+export async function buildWebhookView(): Promise<WebhookView | null> {
+  const store = webhookStore()
+  if (store === null) return null
+
+  const summaries = await store.listAll()
+  const subscriptions = await Promise.all(
+    summaries.map(async (summary) => ({
+      id: summary.id,
+      url: summary.url,
+      topics: summary.topics,
+      active: summary.active,
+      format: summary.format,
+      createdAt: summary.createdAt,
+      delivered: summary.delivered,
+      pending: summary.pending,
+      dead: summary.dead,
+      recent: await store.recentDeliveries(summary.id, 10),
+    })),
+  )
+
+  return { subscriptions, topics: WEBHOOK_TOPICS, formats: WEBHOOK_FORMATS }
+}
+
+export interface CreateWebhookInput {
+  readonly url: string
+  readonly topics: readonly string[]
+  readonly format: string
+  readonly active: boolean
+  readonly createdBy: number | null
+}
+
+function validUrl(raw: string): string {
+  const url = raw.trim()
+  let parsed: URL
+  try {
+    parsed = new URL(url)
+  } catch {
+    throw new ValidationError(msg('error.app.webhook-url-https'))
+  }
+  if (parsed.protocol !== 'https:') {
+    throw new ValidationError(msg('error.app.webhook-url-https'))
+  }
+  return url
+}
+
+export async function createWebhook(input: CreateWebhookInput): Promise<string> {
+  const store = webhookStore()
+  if (store === null) throw new ValidationError(msg('error.app.board-database-webhooks'))
+
+  const url = validUrl(input.url)
+
+  const topics = input.topics.filter((topic): topic is WebhookTopic => isWebhookTopic(topic))
+  if (topics.length === 0) {
+    throw new ValidationError(msg('error.app.webhook-needs-at-least-one-topic'))
+  }
+
+  const format: WebhookFormat = isWebhookFormat(input.format) ? input.format : 'json'
+
+  const secret = generateWebhookSecret()
+  await store.create({
+    url,
+    secret,
+    topics,
+    active: input.active,
+    format,
+    createdBy: input.createdBy,
+  })
+
+  return secret
+}

package/src/styles/globals.css

@@ -666,7 +666,7 @@
   /* `em`, so a quote inside a heading scales with the text it is in. */
   margin-block: 0.85em;
   padding: 0.55em 0.85em;
-  border-inline-start: 3px solid var(--border);
+  border-inline-start: 3px solid color-mix(in srgb, var(--primary) 55%, transparent);
   background-color: var(--muted);
   border-start-end-radius: var(--radius);
   border-end-end-radius: var(--radius);