@meith/web 0.36.1 → 0.37.0

package/src/components/admin/system-run-details.tsx

@@ -0,0 +1,72 @@
+import type { Translator } from '@meith/i18n'
+
+import { systemRunDetail } from '@/view/system-run-detail'
+
+const FIELD_KEYS: Readonly<Record<string, string>> = {
+  attempted: 'adminSystem.result.attempted',
+  delivered: 'adminSystem.result.delivered',
+  retried: 'adminSystem.result.retried',
+  dead: 'adminSystem.result.dead',
+  relayed: 'adminSystem.result.relayed',
+  processed: 'adminSystem.result.processed',
+  removed: 'adminSystem.result.removed',
+  corrected: 'adminSystem.result.corrected',
+  flushed: 'adminSystem.result.flushed',
+  rendered: 'adminSystem.result.rendered',
+  indexed: 'adminSystem.result.indexed',
+  ok: 'adminSystem.result.ok',
+  listingCount: 'adminSystem.result.listingCount',
+  notified: 'adminSystem.result.notified',
+  promoted: 'adminSystem.result.promoted',
+  lifted: 'adminSystem.result.lifted',
+  expired: 'adminSystem.result.expired',
+  deleted: 'adminSystem.result.deleted',
+  failed: 'adminSystem.result.failed',
+  memberCount: 'adminSystem.result.memberCount',
+  online: 'adminSystem.result.online',
+  record: 'adminSystem.result.record',
+  ran: 'adminSystem.result.ran',
+  trigger: 'adminSystem.result.trigger',
+  bundle: 'adminSystem.result.bundle',
+  status: 'adminSystem.result.status',
+  skipped: 'adminSystem.result.skipped',
+}
+
+export function SystemRunDetails({
+  detail,
+  translator,
+}: {
+  detail: string | null
+  translator: Translator
+}) {
+  const fields = systemRunDetail(detail)
+  if (fields.length === 0) return null
+
+  const label = (key: string) => {
+    const message = Object.hasOwn(FIELD_KEYS, key) ? FIELD_KEYS[key] : undefined
+    if (message !== undefined) return translator.t(message)
+    const words = key.replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/[_-]+/g, ' ')
+    return words.charAt(0).toUpperCase() + words.slice(1)
+  }
+
+  return (
+    <dl className="mt-2 grid gap-x-6 gap-y-1 text-xs sm:grid-cols-2">
+      {fields.map((field) => (
+        <div key={JSON.stringify(field.path)} className="flex min-w-0 flex-wrap gap-x-2">
+          <dt className="text-muted-foreground">
+            {field.path.length === 0
+              ? translator.t('adminSystem.result.value')
+              : field.path.map(label).join(' / ')}
+          </dt>
+          <dd className="min-w-0 break-words font-medium [overflow-wrap:anywhere]">
+            {field.value === null
+              ? translator.t('adminSystem.result.empty')
+              : typeof field.value === 'boolean'
+                ? translator.t(field.value ? 'adminSystem.result.yes' : 'adminSystem.result.no')
+                : String(field.value)}
+          </dd>
+        </div>
+      ))}
+    </dl>
+  )
+}

package/src/server/auth-config.ts

@@ -25,10 +25,10 @@ export async function boardAuthConfig(): Promise<AuthConfig> {
   if (env.DATA_SOURCE !== 'postgres') return AUTH_CONFIG
 
   const settings = await getSettings()
-  return demoOverrides({
+  return {
     ...AUTH_CONFIG,
     ...resolveAuthPolicy((key) => settings.get(key as never), AUTH_CONFIG),
-  })
+  }
 }
 
 export async function boardSessionConfig(): Promise<BoardSessionConfig> {
@@ -37,14 +37,3 @@ export async function boardSessionConfig(): Promise<BoardSessionConfig> {
     sessionLifetimeDays: (await boardAuthConfig()).sessionLifetimeDays,
   }
 }
-
-function demoOverrides(config: AuthConfig): AuthConfig {
-  if (!env.DEMO_MODE) return config
-
-  return {
-    ...config,
-    maxLoginAttempts: 50,
-    maxAccountLoginAttempts: 500,
-    lockoutMinutes: 1,
-  }
-}

package/src/server/board-latest.tsx

@@ -12,6 +12,7 @@ import { distinctUserIds } from '@/view/member-identity'
 import { getContainer } from './container'
 import { activeWordFilter } from './content-admin'
 import { getActor } from './context'
+import { FixtureActivityRepository } from './fixture-activity-repo'
 import { identitiesFor } from './group-identity'
 import { filterView, viewerRef } from './plugin-view'
 import { currentTheme } from './theme'
@@ -21,8 +22,10 @@ export const LATEST_ROWS = 5
 
 export const LATEST_REFRESH_SECONDS = 60
 
-export function latestRepository(): PostgresLatestRepository | null {
-  return getContainer().dataSource === 'postgres' ? new PostgresLatestRepository(getDb()) : null
+export function latestRepository(): PostgresLatestRepository | FixtureActivityRepository {
+  return getContainer().dataSource === 'postgres'
+    ? new PostgresLatestRepository(getDb())
+    : new FixtureActivityRepository()
 }
 
 export async function latestScopeFor(actor: Actor): Promise<LatestScope> {
@@ -37,7 +40,6 @@ export async function latestScopeFor(actor: Actor): Promise<LatestScope> {
 
 export async function renderLatestPanels(): Promise<React.ReactNode> {
   const repo = latestRepository()
-  if (repo === null) return null
 
   const actor = await getActor()
   const now = new Date()

package/src/server/container.ts

@@ -63,7 +63,6 @@ import {
   PostgresThreadWriteRepository,
   PostgresWarningRepository,
 } from '@meith/db'
-import { demoResetTask } from '@meith/demo'
 import type { DraftRepository } from '@meith/drafts'
 import { drivers } from '@meith/drivers'
 import { imageProcessor } from '@meith/drivers/images'
@@ -103,7 +102,6 @@ import {
   REMEMBER_DAYS,
   SESSION_LIFETIME_DAYS,
 } from './auth-config'
-import { clearUploadedFiles } from './demo-uploads'
 import { FixtureActorSource } from './fixture-actor-source'
 import { FixtureForumRepository } from './fixture-forum-repo'
 import { FixtureMemberProfileRepository } from './fixture-member-profile-repo'
@@ -296,47 +294,27 @@ function buildPostgres(onBypass: (e: BypassEvent) => void): Container {
     fixtureDataVersion: null,
     accountStore: store,
     ...identityServices(store, new PostgresBanFilterRepository(db), new PostgresBanRepository(db)),
-    scheduler: withDemoReset(
-      buildSchedulerBundle({
-        queue: drivers().queue,
-        db,
-        mail: drivers().mail,
-        themeKey: forumConfig.defaultTheme,
-        themeTokens: Object.fromEntries(
-          Object.values(forumConfig.themes).map((theme) => [theme.key, theme.tokens]),
-        ),
-        themeVersions: Object.values(forumConfig.themes).map((theme) => ({
-          key: theme.key,
-          version: theme.theme?.version ?? null,
-        })),
-        files: drivers().files,
-        images: imageProcessor,
-        plugins: activeDefinitions(),
-        translatorForLocale,
-      }),
+    scheduler: buildSchedulerBundle({
+      queue: drivers().queue,
       db,
-    ),
+      mail: drivers().mail,
+      themeKey: forumConfig.defaultTheme,
+      themeTokens: Object.fromEntries(
+        Object.values(forumConfig.themes).map((theme) => [theme.key, theme.tokens]),
+      ),
+      themeVersions: Object.values(forumConfig.themes).map((theme) => ({
+        key: theme.key,
+        version: theme.theme?.version ?? null,
+      })),
+      files: drivers().files,
+      images: imageProcessor,
+      plugins: activeDefinitions(),
+      translatorForLocale,
+    }),
     dataSource: 'postgres',
   }
 }
 
-function withDemoReset(bundle: SchedulerBundle, db: ReturnType<typeof getDb>): SchedulerBundle {
-  if (!env.DEMO_MODE) return bundle
-
-  return {
-    ...bundle,
-    tasks: [
-      ...bundle.tasks,
-      demoResetTask({
-        db,
-        cache: drivers().cache,
-        clearUploads: () => clearUploadedFiles(),
-        plugins: activeDefinitions(),
-      }),
-    ],
-  }
-}
-
 export function getContainer(): Container {
   const g = globalThis as GlobalWithContainer
   const cached = g[GLOBAL_KEY] as Partial<Container> | undefined

package/src/server/federation-actions.ts

@@ -10,7 +10,6 @@ import type { FormState } from './auth-form-state'
 import { getContainer } from './container'
 import { getActor } from './context'
 import { requireFreshCredentialProof } from './credential-proof'
-import { assertDemoAccountChangeable } from './demo'
 import {
   federationService,
   memberManagedSignIns,
@@ -53,8 +52,6 @@ async function requireOwnAccount(): Promise<{
     throw new ForbiddenError(msg('error.app.board-manages-sign-ins-for-its'))
   }
 
-  await assertDemoAccountChangeable(actor.userId, 'password')
-
   const account = await getContainer().accountStore.accounts.findById(actor.userId)
   if (account === null) throw new ForbiddenError(msg('error.app.account-longer-exists'))
 

package/src/server/fixture-activity-repo.ts

@@ -0,0 +1,127 @@
+import 'server-only'
+
+import { audienceFilterIn, authorFilterAdmits } from '@meith/core'
+import type {
+  BoardTotals,
+  LatestPostRow,
+  LatestScope,
+  LatestThreadRow,
+  TopPoster,
+  TopThread,
+} from '@meith/db'
+
+import {
+  SEED_FORUM_ROWS,
+  SEED_MEMBER_PROFILES,
+  SEED_POST_ROWS,
+  SEED_THREAD_ROWS,
+} from './seed-board'
+
+const forums = new Map(SEED_FORUM_ROWS.map((row) => [row.id, row]))
+const threads = new Map(SEED_THREAD_ROWS.map((row) => [row.id, row]))
+const firstPosts = new Map(
+  SEED_POST_ROWS.filter((post) => post.isFirstPost).map((post) => [post.threadId, post]),
+)
+
+function visibleThreads(scope: LatestScope) {
+  return SEED_THREAD_ROWS.filter(
+    (thread) =>
+      scope.content.states.includes(thread.visibility) &&
+      authorFilterAdmits(audienceFilterIn(scope, thread.forumId), thread.authorUserId),
+  )
+}
+
+export class FixtureActivityRepository {
+  async threads(limit: number, scope: LatestScope): Promise<readonly LatestThreadRow[]> {
+    return visibleThreads(scope)
+      .map((thread) => ({
+        threadId: thread.id,
+        title: thread.title,
+        slug: thread.slug,
+        forumId: thread.forumId,
+        forumTitle: forums.get(thread.forumId)!.title,
+        forumSlug: forums.get(thread.forumId)!.slug,
+        authorUserId: thread.authorUserId,
+        authorUsername: thread.authorUsername,
+        replyCount: thread.replyCount,
+        createdAt: firstPosts.get(thread.id)!.createdAt,
+      }))
+      .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime() || b.threadId - a.threadId)
+      .slice(0, limit)
+  }
+
+  async posts(limit: number, scope: LatestScope): Promise<readonly LatestPostRow[]> {
+    const visible = new Set(visibleThreads(scope).map((thread) => thread.id))
+    return SEED_POST_ROWS.filter(
+      (post) => visible.has(post.threadId) && scope.content.states.includes(post.visibility),
+    )
+      .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime() || b.id - a.id)
+      .slice(0, limit)
+      .map((post) => ({
+        postId: post.id,
+        threadId: post.threadId,
+        threadTitle: threads.get(post.threadId)!.title,
+        threadSlug: threads.get(post.threadId)!.slug,
+        forumId: post.forumId,
+        forumTitle: forums.get(post.forumId)!.title,
+        forumSlug: forums.get(post.forumId)!.slug,
+        authorUserId: post.authorUserId,
+        authorUsername: post.authorUsername,
+        createdAt: post.createdAt,
+        messageSource: post.message.slice(0, 300),
+      }))
+  }
+
+  async readTotals(): Promise<BoardTotals> {
+    const newest = [...SEED_MEMBER_PROFILES].sort(
+      (a, b) => b.createdAt.getTime() - a.createdAt.getTime() || b.id - a.id,
+    )[0]
+    return {
+      threadCount: SEED_THREAD_ROWS.length,
+      postCount: SEED_POST_ROWS.length,
+      memberCount: SEED_MEMBER_PROFILES.length,
+      newestUserId: newest?.id ?? null,
+      newestUsername: newest?.username ?? null,
+      computedAt: newest?.lastActiveAt ?? null,
+    }
+  }
+
+  async topPosters(limit: number): Promise<readonly TopPoster[]> {
+    return [...SEED_MEMBER_PROFILES]
+      .filter((member) => member.postCount > 0)
+      .sort((a, b) => b.postCount - a.postCount || a.id - b.id)
+      .slice(0, limit)
+      .map((member) => ({
+        userId: member.id,
+        username: member.username,
+        postCount: member.postCount,
+      }))
+  }
+
+  async mostViewed(limit: number, scope: LatestScope): Promise<readonly TopThread[]> {
+    return this.topThreads(limit, scope, 'viewCount')
+  }
+
+  async mostReplied(limit: number, scope: LatestScope): Promise<readonly TopThread[]> {
+    return this.topThreads(limit, scope, 'replyCount')
+  }
+
+  private topThreads(
+    limit: number,
+    scope: LatestScope,
+    key: 'viewCount' | 'replyCount',
+  ): readonly TopThread[] {
+    return visibleThreads(scope)
+      .sort((a, b) => b[key] - a[key] || a.id - b.id)
+      .slice(0, limit)
+      .map((thread) => ({
+        threadId: thread.id,
+        title: thread.title,
+        slug: thread.slug,
+        forumId: thread.forumId,
+        forumTitle: forums.get(thread.forumId)!.title,
+        viewCount: thread.viewCount,
+        replyCount: thread.replyCount,
+      }))
+  }
+}