@meith/web 0.16.0

package/src/server/notification-actions.ts

@@ -0,0 +1,84 @@
+'use server'
+
+import { redirect } from 'next/navigation'
+
+import { ForbiddenError } 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 { positiveInt } from './form-values'
+import { tr } from './i18n'
+import { audiencesForActor } from './notification-audience'
+import { notificationService } from './notifications'
+import { pushAvailability } from './push'
+
+const toFormState = formStateReporter('notification-actions', 'unexpected error in notifications')
+
+async function requireOwnCentre(): 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'))
+  }
+  return { service, userId: actor.userId }
+}
+
+export async function markNotificationReadAction(
+  _prev: FormState,
+  form: FormData,
+): Promise<FormState> {
+  const notificationId = positiveInt(form, 'notificationId')
+  if (notificationId === null) return { error: await tr('notice.app.notification-exist') }
+
+  try {
+    const { service, userId } = await requireOwnCentre()
+    await service.markRead(userId, notificationId)
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/notifications?read=one')
+}
+
+export async function markAllNotificationsReadAction(
+  _prev: FormState,
+  _form: FormData,
+): Promise<FormState> {
+  try {
+    const { service, userId } = await requireOwnCentre()
+    await service.markAllRead(userId)
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/notifications?read=all')
+}
+
+export async function saveNotificationPreferencesAction(
+  _prev: FormState,
+  form: FormData,
+): Promise<FormState> {
+  try {
+    const { service, userId } = await requireOwnCentre()
+    const email = form.getAll('email').filter((value): value is string => typeof value === 'string')
+    const push = form.getAll('push').filter((value): value is string => typeof value === 'string')
+    const offersPush = (await pushAvailability()).enabled
+
+    for (const audience of await audiencesForActor()) {
+      await service.savePreferences(userId, audience, email, 'email')
+      if (offersPush) await service.savePreferences(userId, audience, push, 'push')
+    }
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect('/notifications/preferences?saved=1')
+}

package/src/server/notification-audience.ts

@@ -0,0 +1,10 @@
+import 'server-only'
+
+import { getActor } from './context'
+
+export type PreferenceAudience = 'member' | 'staff'
+
+export async function audiencesForActor(): Promise<readonly PreferenceAudience[]> {
+  const actor = await getActor()
+  return actor.global.canAccessAdminCp === true ? ['member', 'staff'] : ['member']
+}

package/src/server/notification-menu-actions.ts

@@ -0,0 +1,82 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+
+import { ForbiddenError } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+import type { FormState } from './auth-form-state'
+import { EMPTY_STATE } from './auth-form-state'
+import { getActor } from './context'
+import { formStateReporter } from './form-state-reporter'
+import { positiveInt } from './form-values'
+import { requireMessaging } from './messages'
+import { notificationService } from './notifications'
+
+const toFormState = formStateReporter(
+  'notification-menu-actions',
+  'unexpected error in the notifications menu',
+)
+
+function refreshShell(): void {
+  revalidatePath('/', 'layout')
+}
+
+export async function markNotificationSeenAction(
+  _prev: FormState,
+  form: FormData,
+): Promise<FormState> {
+  const notificationId = positiveInt(form, 'notificationId')
+  if (notificationId === null) return EMPTY_STATE
+
+  try {
+    const actor = await getActor()
+    if (actor.userId === null) throw new ForbiddenError(msg('error.app.must-logged'))
+
+    const service = notificationService()
+    if (service !== null) await service.markRead(actor.userId, notificationId)
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  refreshShell()
+  return EMPTY_STATE
+}
+
+export async function markAllNotificationsSeenAction(
+  _prev: FormState,
+  _form: FormData,
+): 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) await service.markAllRead(actor.userId)
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  refreshShell()
+  return EMPTY_STATE
+}
+
+export async function markMessagesSeenAction(_prev: FormState, form: FormData): Promise<FormState> {
+  const copyIds = form
+    .getAll('copyId')
+    .filter((value): value is string => typeof value === 'string')
+    .map((value) => Number(value))
+    .filter((value) => Number.isInteger(value) && value > 0)
+
+  if (copyIds.length === 0) return EMPTY_STATE
+
+  try {
+    const { service, userId } = await requireMessaging(await getActor())
+    await service.markRead(userId, copyIds)
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  refreshShell()
+  return EMPTY_STATE
+}

package/src/server/notification-menu.ts

@@ -0,0 +1,96 @@
+import 'server-only'
+
+import type { Actor } from '@meith/authorization'
+import type { MessageListRow } from '@meith/messages'
+import { ModerationQueue, type QueueItem, type ReportRow, ReportService } from '@meith/moderation'
+import type { NotificationView } from '@meith/notifications'
+
+import {
+  buildNotificationMenuView,
+  type ModerationSummary,
+  type NotificationMenuModel,
+} from '../view/notification-menu'
+import { getContainer } from './container'
+import { getTranslator } from './i18n'
+import { messageService, unreadMessageCount } from './messages'
+import { modCpCounts, resolveModCpAccess } from './modcp'
+import { notificationService, unreadNotificationCount } from './notifications'
+import { hasReportScope, resolveReportScope } from './report-scope'
+
+async function moderationSummary(): Promise<ModerationSummary | null> {
+  const access = await resolveModCpAccess()
+  if (access === null) return null
+
+  const { moderationQueue, reports } = getContainer()
+
+  const counts = await modCpCounts()
+
+  const queue: readonly QueueItem[] =
+    moderationQueue === null
+      ? []
+      : await new ModerationQueue({ queue: moderationQueue })
+          .list(access.forumIds, { offset: 0 })
+          .then((page) => page.items)
+          .catch(() => [])
+
+  const scope = await resolveReportScope()
+  const reportRows: readonly ReportRow[] =
+    reports === null || !hasReportScope(scope)
+      ? []
+      : await new ReportService({ reports })
+          .listOpen(scope, { offset: 0 })
+          .then((page) => page.rows)
+          .catch(() => [])
+
+  return {
+    queue,
+    reports: reportRows,
+    pending: counts.pending,
+    openReports: counts.openReports,
+  }
+}
+
+export async function buildNotificationMenuModel(
+  actor: Actor,
+): Promise<NotificationMenuModel | null> {
+  if (actor.userId === null) return null
+
+  const { authorizer } = getContainer()
+  const translator = await getTranslator()
+  const now = new Date()
+
+  const notifications = notificationService()
+  const notificationRows: readonly NotificationView[] =
+    notifications === null
+      ? []
+      : await notifications
+          .list(actor.userId, {}, translator)
+          .then((page) => page.rows)
+          .catch(() => [])
+
+  const canPm = authorizer.can(actor, 'pm.use')
+  const messages = messageService()
+  const messageRows: readonly MessageListRow[] =
+    !canPm || messages === null
+      ? []
+      : await messages
+          .list({ userId: actor.userId, folder: 'inbox', offset: 0 })
+          .then((page) => page.rows)
+          .catch(() => [])
+
+  const [notificationsUnread, messagesUnread, moderation] = await Promise.all([
+    unreadNotificationCount(actor.userId),
+    canPm ? unreadMessageCount(actor.userId) : Promise.resolve(0),
+    moderationSummary(),
+  ])
+
+  return buildNotificationMenuView({
+    notifications: notificationRows,
+    notificationsUnread,
+    messages: messageRows,
+    messagesUnread,
+    moderation,
+    now,
+    t: translator,
+  })
+}

package/src/server/notifications.ts

@@ -0,0 +1,93 @@
+import 'server-only'
+
+import forumConfig from '@board/config'
+import { cache } from 'react'
+
+import { currentRequestId } from '@meith/core/logger'
+import type { ReportNotifierPort, WarningNotifierPort } from '@meith/moderation'
+import { type NotificationAudit, NotificationService } from '@meith/notifications'
+import {
+  type PluginDefinition,
+  type PluginNotificationKindSpec,
+  pluginNotificationKindSpecs,
+} from '@meith/plugin-kit'
+
+import { getContainer } from './container'
+import { emitEvent, filterView } from './plugin-view'
+
+const PLUGIN_KINDS: readonly PluginNotificationKindSpec[] = (forumConfig.plugins ?? []).flatMap(
+  (entry) => {
+    if (entry.enabled === false) return []
+    const definition = entry.plugin as PluginDefinition | undefined
+    if (definition === undefined) return []
+    return pluginNotificationKindSpecs(definition.key, definition.notifications ?? [])
+  },
+)
+
+const PLUGIN_AUDIT: NotificationAudit = {
+  before: (input) =>
+    filterView('notification.create.before', input, { requestId: currentRequestId() ?? null }),
+
+  created: (input) =>
+    emitEvent('notification.created', input, { requestId: currentRequestId() ?? null }),
+}
+
+export function notificationService(): NotificationService | null {
+  const { notifications } = getContainer()
+  return notifications === null
+    ? null
+    : new NotificationService({ notifications, extraKinds: PLUGIN_KINDS, audit: PLUGIN_AUDIT })
+}
+
+export function warningNotifier(): WarningNotifierPort | null {
+  const service = notificationService()
+  if (service === null) return null
+
+  return {
+    async warned(input) {
+      await service.raise({
+        userId: input.userId,
+        kind: 'warning.received',
+        data: {
+          title: input.title,
+          points: input.points,
+          totalPoints: input.totalPoints,
+          reason: input.reason,
+          restriction: input.restriction,
+        },
+        href: null,
+      })
+    },
+  }
+}
+
+export function reportNotifier(): ReportNotifierPort | null {
+  const service = notificationService()
+  if (service === null) return null
+
+  return {
+    async reportClosed(input) {
+      await service.raise({
+        userId: input.reporterUserId,
+        kind: 'report.actioned',
+        data: { outcome: input.outcome, targetLabel: input.targetLabel },
+        dedupeKey: `report.actioned:${input.reportId}`,
+        href: null,
+      })
+    },
+  }
+}
+
+export const unreadNotificationCount = cache(async function unreadNotificationCount(
+  userId: number | null,
+): Promise<number> {
+  if (userId === null) return 0
+  const service = notificationService()
+  if (service === null) return 0
+
+  try {
+    return await service.unreadCount(userId)
+  } catch {
+    return 0
+  }
+})

package/src/server/onboarding-actions.ts

@@ -0,0 +1,27 @@
+'use server'
+
+import { cookies } from 'next/headers'
+
+import {
+  isOnboardingPanel,
+  ONBOARDING_COOKIE_MAX_AGE,
+  onboardingCookieName,
+} from '@/view/onboarding'
+
+import { redirectToCurrentPath } from './redirect-back'
+
+const COOKIE_OPTIONS = {
+  path: '/',
+  maxAge: ONBOARDING_COOKIE_MAX_AGE,
+  sameSite: 'lax',
+  httpOnly: false,
+} as const
+
+export async function dismissOnboardingAction(form: FormData): Promise<void> {
+  const panel = form.get('panel')
+  if (typeof panel === 'string' && isOnboardingPanel(panel)) {
+    ;(await cookies()).set(onboardingCookieName(panel), '1', COOKIE_OPTIONS)
+  }
+
+  await redirectToCurrentPath()
+}

package/src/server/onboarding.ts

@@ -0,0 +1,89 @@
+import 'server-only'
+
+import { cookies } from 'next/headers'
+
+import type { Actor } from '@meith/authorization'
+
+import {
+  hasCompleteProfile,
+  isNewMember,
+  type OnboardingPanel,
+  onboardingCookieName,
+} from '@/view/onboarding'
+
+import { avatarsFor } from './avatars'
+import { getContainer } from './container'
+import { getTranslator } from './i18n'
+import { legalDocument } from './legal'
+
+export interface OnboardingNoticeModel {
+  readonly panel: OnboardingPanel
+  readonly message: string
+  readonly ctaHref: string | null
+  readonly ctaLabel: string | null
+  readonly dismissLabel: string
+}
+
+async function dismissed(panel: OnboardingPanel): Promise<boolean> {
+  return (await cookies()).get(onboardingCookieName(panel))?.value === '1'
+}
+
+/**
+ * At most one of the welcome banner or the profile-completion nudge, never
+ * both — stacking unrelated notices in the same board-wide slot is the
+ * "heavy multi-step tour" the feature is meant to avoid.
+ */
+export async function onboardingBanner(actor: Actor): Promise<OnboardingNoticeModel | null> {
+  if (actor.userId === null) return null
+
+  const profile = await getContainer()
+    .memberProfiles.findPublicById(actor.userId)
+    .catch(() => null)
+  if (profile === null || !isNewMember(profile.postCount)) return null
+
+  const t = await getTranslator()
+  const dismissLabel = t.t('onboarding.dismiss')
+
+  if (!(await dismissed('welcome'))) {
+    return {
+      panel: 'welcome',
+      message: t.t('onboarding.welcome.message'),
+      ctaHref: null,
+      ctaLabel: null,
+      dismissLabel,
+    }
+  }
+
+  const avatarUrl = (await avatarsFor([actor.userId])).get(actor.userId) ?? null
+  if (!hasCompleteProfile({ avatarUrl, bio: profile.bio }) && !(await dismissed('profile'))) {
+    return {
+      panel: 'profile',
+      message: t.t('onboarding.profile.message'),
+      ctaHref: '/usercp/profile',
+      ctaLabel: t.t('onboarding.profile.cta'),
+      dismissLabel,
+    }
+  }
+
+  return null
+}
+
+export async function firstPostGuidance(actor: Actor): Promise<OnboardingNoticeModel | null> {
+  if (actor.userId === null || (await dismissed('first-post'))) return null
+
+  const profile = await getContainer()
+    .memberProfiles.findPublicById(actor.userId)
+    .catch(() => null)
+  if (profile === null || !isNewMember(profile.postCount)) return null
+
+  const rules = await legalDocument('rules')
+  const t = await getTranslator()
+
+  return {
+    panel: 'first-post',
+    message: t.t('onboarding.firstPost.message'),
+    ctaHref: rules?.href ?? null,
+    ctaLabel: rules === null ? null : t.t('onboarding.firstPost.cta'),
+    dismissLabel: t.t('onboarding.dismiss'),
+  }
+}

package/src/server/page-metadata.ts

@@ -0,0 +1,14 @@
+import 'server-only'
+
+import { filterView } from './plugin-view'
+
+export interface PageMetadata {
+  readonly title: string
+  readonly description: string | null
+  readonly canonical: string
+  readonly imageUrl: string | null
+}
+
+export async function pageMetadata(route: string, page: PageMetadata): Promise<PageMetadata> {
+  return filterView('metadata.page', page, { route })
+}

package/src/server/passkey-challenge.ts

@@ -0,0 +1,42 @@
+import 'server-only'
+
+export type PasskeyPurpose = 'register' | 'authenticate' | 'second-factor' | 'credential-proof'
+
+export interface PasskeyChallenge {
+  readonly challenge: string
+  readonly userId?: number
+  readonly sessionId?: number
+  readonly provedAt?: number
+}
+
+export function packChallenge(
+  purpose: PasskeyPurpose,
+  challenge: string,
+  binding: Omit<PasskeyChallenge, 'challenge'> = {},
+): string {
+  return `${purpose}:${encodeURIComponent(JSON.stringify({ challenge, ...binding }))}`
+}
+
+export function unpackChallenge(
+  raw: string | undefined,
+  purpose: PasskeyPurpose,
+): PasskeyChallenge | null {
+  if (raw === undefined) return null
+
+  const separator = raw.indexOf(':')
+  if (separator < 0 || raw.slice(0, separator) !== purpose) return null
+
+  try {
+    const value = JSON.parse(decodeURIComponent(raw.slice(separator + 1))) as Record<
+      string,
+      unknown
+    >
+    if (typeof value.challenge !== 'string' || value.challenge === '') return null
+    if (value.userId !== undefined && !Number.isInteger(value.userId)) return null
+    if (value.sessionId !== undefined && !Number.isInteger(value.sessionId)) return null
+    if (value.provedAt !== undefined && !Number.isInteger(value.provedAt)) return null
+    return value as unknown as PasskeyChallenge
+  } catch {
+    return null
+  }
+}