@meith/runtime 0.16.0

package/src/scheduler-bundle.ts

@@ -0,0 +1,373 @@
+import { AttachmentService, type ImageProcessor } from '@meith/attachments'
+import { Authorizer } from '@meith/authorization'
+import { AvatarService } from '@meith/avatars'
+import type { FileStore, MailDriver, QueueDriver } from '@meith/core'
+import { env, logger, metrics, optional, withSpan } from '@meith/core'
+import {
+  ActorBuilder,
+  type Database,
+  expireTimedGroupMemberships,
+  getDb,
+  PostgresAttachmentRepository,
+  PostgresAuthEventRepository,
+  PostgresAuthorizationSource,
+  PostgresAvatarRepository,
+  PostgresBanRepository,
+  PostgresContentCounterRepository,
+  PostgresCounterRecount,
+  PostgresMaintenanceRepository,
+  PostgresMarketplaceCacheRepository,
+  PostgresNotificationRepository,
+  PostgresOutboxReader,
+  PostgresPresenceRepository,
+  PostgresPromotionRepository,
+  PostgresRateLimitBucketStore,
+  PostgresRenderBackfill,
+  PostgresSearchRepository,
+  PostgresSettingsRepository,
+  PostgresStatsRepository,
+  PostgresSubscriptionRepository,
+  PostgresTaskRepository,
+  PostgresThreadViewBuffer,
+  PostgresUserBulkRepository,
+  PostgresWarningRepository,
+  PostgresWebhookRepository,
+  readPluginHealth,
+  recordPluginFailure,
+  syncRenderSignature,
+} from '@meith/db'
+import { EN_CATALOG, sourceTranslator } from '@meith/i18n'
+import { renderMail } from '@meith/mail'
+import {
+  deliverNotificationEmail,
+  deliverNotificationPush,
+  NotificationService,
+  type NotificationTranslatorResolver,
+  type VapidDetails,
+} from '@meith/notifications'
+import { type PluginDefinition, PluginHost, renderingSignature } from '@meith/plugin-kit'
+import { resolvePushConfig, SettingsSnapshot } from '@meith/settings'
+import { builtinTasks, type TaskDefinition, type TaskRepository } from '@meith/tasks'
+
+import { buildEventRegistry } from './event-handlers'
+import { SEED_GROUP } from './groups'
+import { resolveMailBrand, type ThemeTokenRegistry } from './mail-brand'
+import { pluginMarkdownPipeline, sendAudited } from './plugin-rendering'
+import { pluginTasks } from './plugin-tasks'
+import { defaultPromotionGuards, taskWorkers } from './task-workers'
+import { visibleForumSource } from './visible-forums'
+
+export interface SchedulerBundle {
+  readonly repository: TaskRepository
+  readonly tasks: readonly TaskDefinition[]
+  readonly onTaskFailure: (taskId: string, error: unknown) => void
+}
+
+export function buildSchedulerBundle(deps: {
+  readonly queue: QueueDriver
+  readonly db?: Database
+  readonly mail?: MailDriver
+  readonly themeKey?: string
+  readonly themeTokens?: ThemeTokenRegistry
+  readonly files?: FileStore
+  readonly images?: ImageProcessor
+  readonly plugins?: readonly PluginDefinition[]
+  readonly translatorForLocale?: NotificationTranslatorResolver
+}): SchedulerBundle {
+  const db = deps.db ?? getDb()
+  const themeDeps = {
+    ...optional(deps.themeKey, (themeKey) => ({ themeKey })),
+    ...optional(deps.themeTokens, (themeTokens) => ({ themeTokens })),
+  }
+  const threadViews = new PostgresThreadViewBuffer(db)
+  const notifications = new PostgresNotificationRepository(db)
+  const mail = deps.mail
+
+  const attachmentService =
+    deps.files === undefined || deps.images === undefined
+      ? undefined
+      : new AttachmentService({
+          attachments: new PostgresAttachmentRepository(db),
+          files: deps.files,
+          images: deps.images,
+        })
+
+  const avatarService =
+    deps.files === undefined || deps.images === undefined
+      ? undefined
+      : new AvatarService({
+          avatars: new PostgresAvatarRepository(db),
+          files: deps.files,
+          images: deps.images,
+        })
+
+  const contributed = pluginTasks({ db, plugins: deps.plugins ?? [] })
+  const plugins = deps.plugins ?? []
+  const renderHost = new PluginHost({
+    plugins,
+    health: {
+      failed: (failure) => {
+        void recordPluginFailure(db, {
+          pluginKey: failure.pluginKey,
+          threshold: failure.threshold,
+          reason: `${failure.threshold} failures, most recently in "${failure.hook}": ${failure.message}`,
+        }).catch((error: unknown) => {
+          logger({ module: 'scheduler' }).warn(
+            { err: String(error), plugin: failure.pluginKey },
+            'could not record plugin failure',
+          )
+        })
+      },
+    },
+  })
+  const backfill = new PostgresRenderBackfill(db, pluginMarkdownPipeline(renderHost))
+
+  const taskRuns = metrics.counter(
+    'meith_task_runs_total',
+    'Scheduled task runs, labelled by task and outcome.',
+  )
+  const taskRunSeconds = metrics.histogram(
+    'meith_task_run_duration_seconds',
+    'Scheduled task run duration in seconds, labelled by task and outcome.',
+  )
+
+  /**
+   * Every task, announced. The host is told before and after each run — a
+   * plugin watching its own task, or the board's, gets the same two events
+   * whichever scheduled it.
+   */
+  const announced = (tasks: readonly TaskDefinition[]): TaskDefinition[] =>
+    tasks.map((task) => ({
+      ...task,
+      async run(context) {
+        await renderHost.emit('task.run.before', { taskId: task.id }, {})
+
+        const startedAt = Date.now()
+        try {
+          const result = await withSpan('task.run', { 'task.id': task.id }, () => task.run(context))
+          const durationMs = Date.now() - startedAt
+          taskRuns.inc(1, { task: task.id, status: 'ok' })
+          taskRunSeconds.observe(durationMs / 1000, { task: task.id })
+          await renderHost.emit('task.run.after', { taskId: task.id, ok: true, durationMs }, {})
+          return result
+        } catch (error) {
+          const durationMs = Date.now() - startedAt
+          taskRuns.inc(1, { task: task.id, status: 'error' })
+          taskRunSeconds.observe(durationMs / 1000, { task: task.id })
+          await renderHost.emit('task.run.after', { taskId: task.id, ok: false, durationMs }, {})
+          throw error
+        }
+      },
+    }))
+
+  return {
+    repository: new PostgresTaskRepository(db),
+    onTaskFailure: taskFailureNotifier(notifications),
+    tasks: announced([
+      ...builtinTasks(
+        taskWorkers({
+          queue: deps.queue,
+          bans: new PostgresBanRepository(db),
+          promotions: new PostgresPromotionRepository(db),
+          guards: defaultPromotionGuards(),
+          maintenance: new PostgresMaintenanceRepository(db),
+          rateLimits: new PostgresRateLimitBucketStore(db),
+          authEvents: {
+            retentionDays: () => authEventRetentionDays(db),
+            pruneBefore: (cutoff, limit) =>
+              new PostgresAuthEventRepository(db).pruneBefore(cutoff, limit),
+          },
+          timedGroups: { expire: (limit) => expireTimedGroupMemberships(db, limit) },
+          outbox: new PostgresOutboxReader(db),
+          ...optional(attachmentService, (attachments) => ({ attachments })),
+          ...optional(avatarService, (avatars) => ({ avatars })),
+          events: buildEventRegistry({
+            counters: new PostgresContentCounterRepository(db),
+            ...optional(attachmentService, (attachments) => ({
+              attachments: { process: (id: number) => attachments.process(id) },
+            })),
+            ...optional(avatarService, (avatars) => ({
+              avatars: { process: (id: number) => avatars.process(id) },
+            })),
+            notifications: {
+              ...optional(mail, (mail) => ({
+                async deliverEmail(notificationId: number) {
+                  await deliverNotificationEmail({
+                    notifications,
+                    mail,
+                    brand: await resolveMailBrand({ db, ...themeDeps }),
+                    notificationId,
+                    ...optional(deps.translatorForLocale, (translatorForLocale) => ({
+                      translatorForLocale,
+                    })),
+                  })
+                },
+              })),
+              async deliverPush(notificationId: number) {
+                const vapid = await vapidDetails(db)
+                if (vapid === null) return
+                await deliverNotificationPush({
+                  notifications,
+                  vapid,
+                  notificationId,
+                  ...optional(deps.translatorForLocale, (translatorForLocale) => ({
+                    translatorForLocale,
+                  })),
+                })
+              },
+            },
+            ...optional(mail, (mail) => ({
+              massMail: {
+                async send({ massMailId, email }) {
+                  const campaign = await new PostgresUserBulkRepository(db).readMassMail(massMailId)
+                  if (campaign === null) return
+
+                  const brand = await resolveMailBrand({ db, ...themeDeps })
+                  const t = await (
+                    deps.translatorForLocale ?? (() => sourceTranslator(EN_CATALOG))
+                  )('')
+
+                  const rendered = renderMail({
+                    brand,
+                    t,
+                    body: {
+                      title: campaign.subject,
+                      paragraphs: campaign.body.split(/\n{2,}/),
+                      footer: [
+                        {
+                          text: t.t('mail.footer.sentBy', {
+                            board:
+                              brand.boardName === '' ? t.t('mail.boardFallback') : brand.boardName,
+                          }),
+                        },
+                      ],
+                    },
+                  })
+
+                  const fromName = brand.fromName ?? ''
+                  await sendAudited(renderHost, mail, 'mass-mail', {
+                    to: email,
+                    subject: campaign.subject,
+                    text: rendered.text,
+                    html: rendered.html,
+                    ...(fromName === '' ? {} : { fromName }),
+                  })
+                },
+              },
+            })),
+          }),
+          recount: new PostgresCounterRecount(db),
+          renderBackfill: {
+            run: async (batchSize) => {
+              renderHost.setDurablyDisabled(
+                (await readPluginHealth(db))
+                  .filter((row) => row.disabledAt !== null)
+                  .map((row) => ({
+                    key: row.pluginKey,
+                    reason: row.reason ?? 'repeated failures',
+                  })),
+              )
+              await syncRenderSignature(db, renderingSignature(plugins))
+              return backfill.run(batchSize)
+            },
+          },
+          searchIndex: new PostgresSearchRepository(db),
+          ...(env.DEMO_MODE ? {} : { webhooks: new PostgresWebhookRepository(db) }),
+          statistics: {
+            stats: new PostgresStatsRepository(db),
+            presence: new PostgresPresenceRepository(db),
+          },
+          threadViews,
+          warnings: new PostgresWarningRepository(db),
+          subscriptions: {
+            repository: new PostgresSubscriptionRepository(db),
+            notifications: new NotificationService({ notifications }),
+            forums: visibleForumSource({
+              authorizer: new Authorizer(new PostgresAuthorizationSource(db), {}),
+              actors: new ActorBuilder(db, { guestGroupId: SEED_GROUP.guest }),
+            }),
+            unsubscribeSecret: env.AUTH_SECRET ?? null,
+          },
+          marketplace: {
+            repository: new PostgresMarketplaceCacheRepository(db),
+            plugins,
+            feedUrl: () => marketplaceFeedUrl(db),
+            async notifyUpdate(listing) {
+              await new NotificationService({ notifications }).raiseForAdministrators({
+                kind: 'marketplace.update_available',
+                data: {
+                  key: listing.key,
+                  name: listing.name,
+                  package: listing.package,
+                  version: listing.version,
+                },
+                href: '/admin/plugins/browse',
+                dedupeKey: `marketplace.update_available:${listing.key}:${listing.version}`,
+              })
+            },
+          },
+        }),
+      ),
+      ...contributed,
+    ]),
+  }
+}
+
+async function marketplaceFeedUrl(db: Database): Promise<string> {
+  try {
+    const overrides = await new PostgresSettingsRepository(db).loadAll()
+    return SettingsSnapshot.fromOverrides(new Map(overrides)).get('marketplace.feed_url')
+  } catch (err) {
+    logger({ module: 'tick' }).warn({ err }, 'could not read the marketplace feed URL setting')
+    return SettingsSnapshot.fromOverrides(new Map()).get('marketplace.feed_url')
+  }
+}
+
+async function vapidDetails(db: Database): Promise<VapidDetails | null> {
+  try {
+    const overrides = await new PostgresSettingsRepository(db).loadAll()
+    const { config } = resolvePushConfig({
+      environment: env,
+      settings: SettingsSnapshot.fromOverrides(new Map(overrides)),
+    })
+    return config
+  } catch (err) {
+    logger({ module: 'tick' }).warn({ err }, 'could not read the web push configuration')
+    return null
+  }
+}
+
+async function authEventRetentionDays(db: Database): Promise<number> {
+  try {
+    const overrides = await new PostgresSettingsRepository(db).loadAll()
+    return SettingsSnapshot.fromOverrides(new Map(overrides)).get(
+      'security.auth_event_retention_days',
+    )
+  } catch (err) {
+    logger({ module: 'tick' }).warn({ err }, 'could not read the sign-in activity retention')
+    return 0
+  }
+}
+
+const ERROR_DETAIL_MAX = 500
+
+function taskFailureNotifier(
+  notifications: PostgresNotificationRepository,
+): (taskId: string, error: unknown) => void {
+  const log = logger({ module: 'tick' })
+
+  return (taskId, error) => {
+    const message = error instanceof Error ? error.message : String(error)
+    log.error({ taskId, err: error }, 'scheduled task failed')
+
+    void new NotificationService({ notifications })
+      .raiseForAdministrators({
+        kind: 'system.task_failed',
+        data: { taskId, error: message.slice(0, ERROR_DETAIL_MAX) },
+        dedupeKey: `system.task_failed:${taskId}`,
+      })
+      .catch((err: unknown) => {
+        log.error({ taskId, err }, 'could not raise the task-failure notification')
+      })
+  }
+}

package/src/task-workers.ts

@@ -0,0 +1,293 @@
+import { type BanRepository, BanService } from '@meith/accounts'
+import type { AttachmentService } from '@meith/attachments'
+import type { AvatarService } from '@meith/avatars'
+import { optional, type QueueDriver } from '@meith/core'
+import { type EventRegistry, type OutboxReader, relayOutbox as runOutboxRelay } from '@meith/events'
+import { type PromotionGuards, PromotionService } from '@meith/groups'
+import {
+  type MarketplaceCacheRepository,
+  type MarketplaceListing,
+  MEITH_VERSION,
+  PLUGIN_API_MAJOR,
+  refreshCatalog,
+  THEME_API_MAJOR,
+} from '@meith/marketplace'
+import { type WarningRepository, WarningService } from '@meith/moderation'
+import type { NotificationService } from '@meith/notifications'
+import type { PluginDefinition } from '@meith/plugin-kit'
+import {
+  SubscriptionNotifier,
+  type SubscriptionRepository,
+  type VisibleForumSource,
+} from '@meith/subscriptions'
+import type { TaskWorkers } from '@meith/tasks'
+
+import { SEED_GROUP } from './groups'
+import { deliverWebhooks, type WebhookDeliveryStore } from './webhook-delivery'
+
+export interface TaskWorkerDeps {
+  readonly queue: QueueDriver
+  readonly bans: BanRepository
+  readonly promotions: ConstructorParameters<typeof PromotionService>[0]['promotions']
+  readonly guards: PromotionGuards
+  readonly maintenance: {
+    pruneSessions(now: Date, limit?: number): Promise<number>
+    pruneExpiredTokens(now: Date, limit?: number): Promise<number>
+  }
+  readonly rateLimits?: { prune(before: Date, limit?: number): Promise<number> }
+  readonly authEvents?: {
+    retentionDays(): Promise<number>
+    pruneBefore(cutoff: Date, limit?: number): Promise<number>
+  }
+  readonly timedGroups?: { expire(limit: number): Promise<number> }
+  readonly outbox: OutboxReader
+  readonly events: EventRegistry
+  readonly recount: { run(batchSize: number): Promise<{ corrected: number }> }
+  readonly threadViews: { flush(limit: number): Promise<number> }
+  readonly renderBackfill: { run(batchSize: number): Promise<{ rendered: number }> }
+  readonly searchIndex?:
+    | { reindexChunk(afterPostId: number, limit: number): Promise<{ indexed: number }> }
+    | undefined
+  readonly webhooks?: WebhookDeliveryStore | undefined
+  readonly warnings: WarningRepository
+  readonly subscriptions?: {
+    readonly repository: SubscriptionRepository
+    readonly notifications: NotificationService
+    readonly forums: VisibleForumSource
+    readonly unsubscribeSecret: string | null
+  }
+  readonly attachments?: AttachmentService
+  readonly avatars?: AvatarService
+  readonly statistics?: {
+    readonly stats: { rollUp(now: Date): Promise<{ memberCount: number }> }
+    readonly presence: {
+      concurrentCount(now: Date): Promise<number>
+      recordIfHigher(count: number, now: Date): Promise<boolean>
+    }
+  }
+  readonly marketplace?: {
+    readonly repository: MarketplaceCacheRepository
+    readonly plugins: readonly PluginDefinition[]
+    readonly feedUrl: () => Promise<string>
+    readonly notifyUpdate: (listing: MarketplaceListing) => Promise<void>
+  }
+}
+
+export function defaultPromotionGuards(): PromotionGuards {
+  return {
+    protectedGroupIds: [SEED_GROUP.banned, SEED_GROUP.administrators, SEED_GROUP.superModerators],
+    rank: new Map([
+      [SEED_GROUP.guest, 0],
+      [SEED_GROUP.registered, 2],
+      [SEED_GROUP.superModerators, 8],
+      [SEED_GROUP.administrators, 9],
+    ]),
+  }
+}
+
+export function taskWorkers(deps: TaskWorkerDeps): Partial<TaskWorkers> {
+  const bans = new BanService({ bans: deps.bans, bannedGroupId: SEED_GROUP.banned })
+  const promotions = new PromotionService({
+    promotions: deps.promotions,
+    guards: deps.guards,
+  })
+
+  return {
+    async relayOutbox(batchSize) {
+      const { claimed } = await runOutboxRelay({
+        reader: deps.outbox,
+        target: {
+          async enqueue(jobs) {
+            for (const job of jobs) {
+              await deps.queue.enqueue(job.name, job.payload, {
+                dedupeKey: job.idempotencyKey,
+              })
+            }
+          },
+        },
+        handlerIdsFor: (event) => deps.events.handlerIdsFor(event),
+        batchSize,
+      })
+      return claimed
+    },
+
+    async drainQueue(batchSize, signal) {
+      const { processed } = await deps.queue.drain(
+        batchSize,
+        async (job) => {
+          await deps.events.dispatch(job.kind, job.payload)
+        },
+        { signal },
+      )
+      return processed
+    },
+
+    async reconcileCounters(batchSize) {
+      const { corrected } = await deps.recount.run(batchSize)
+      return corrected
+    },
+
+    async flushThreadViews(batchSize) {
+      return deps.threadViews.flush(batchSize)
+    },
+
+    async backfillPostRenders(batchSize) {
+      const { rendered } = await deps.renderBackfill.run(batchSize)
+      return rendered
+    },
+
+    ...optional(deps.searchIndex, (searchIndex) => ({
+      async reindexSearch(batchSize: number) {
+        const { indexed } = await searchIndex.reindexChunk(0, batchSize)
+        return indexed
+      },
+    })),
+
+    ...optional(deps.webhooks, (webhooks) => ({
+      async deliverWebhooks(batchSize: number) {
+        return deliverWebhooks(webhooks, batchSize)
+      },
+    })),
+
+    async pruneSessions() {
+      return deps.maintenance.pruneSessions(new Date())
+    },
+
+    async pruneExpiredTokens() {
+      return deps.maintenance.pruneExpiredTokens(new Date())
+    },
+
+    ...(deps.rateLimits === undefined
+      ? {}
+      : {
+          async pruneRateLimits() {
+            const before = new Date(Date.now() - 2 * 3600 * 1000)
+            return deps.rateLimits!.prune(before)
+          },
+        }),
+
+    ...optional(deps.authEvents, (authEvents) => ({
+      async pruneAuthEvents() {
+        const days = await authEvents.retentionDays()
+        if (days <= 0) return 0
+
+        return authEvents.pruneBefore(new Date(Date.now() - days * 86_400_000))
+      },
+    })),
+
+    async applyPromotions(batchSize) {
+      const result = await promotions.apply(batchSize)
+      return result.outcomes.length
+    },
+
+    async expireBans(batchSize) {
+      return bans.expireDue(batchSize)
+    },
+
+    ...optional(deps.timedGroups, (timedGroups) => ({
+      async expireGroupMemberships(batchSize: number) {
+        return timedGroups.expire(batchSize)
+      },
+    })),
+
+    async expireWarnings(batchSize) {
+      return new WarningService({ warnings: deps.warnings, bans: banPort(bans) }).expireDue(
+        batchSize,
+      )
+    },
+
+    ...optional(deps.subscriptions, () => ({
+      async notifySubscribers(batchSize: number, signal: AbortSignal) {
+        const { notified } = await subscriptionNotifier(deps).runInstant(batchSize, signal)
+        return notified
+      },
+
+      async sendDigests(batchSize: number, signal: AbortSignal) {
+        const notifier = subscriptionNotifier(deps)
+        const daily = await notifier.runDigest('daily', batchSize, signal)
+        if (signal.aborted) return daily.notified
+
+        const weekly = await notifier.runDigest('weekly', batchSize, signal)
+        return daily.notified + weekly.notified
+      },
+    })),
+
+    ...optional(deps.attachments, (attachments) => ({
+      async sweepAttachments(batchSize: number) {
+        return attachments.sweep(batchSize)
+      },
+    })),
+
+    ...optional(deps.avatars, (avatars) => ({
+      async sweepAvatars(batchSize: number) {
+        return avatars.sweep(batchSize)
+      },
+    })),
+
+    ...optional(deps.marketplace, (marketplace) => ({
+      async refreshMarketplaceCatalog() {
+        const url = await marketplace.feedUrl()
+        return refreshCatalog({
+          url,
+          repository: marketplace.repository,
+          build: {
+            meithVersion: MEITH_VERSION,
+            pluginApiMajor: PLUGIN_API_MAJOR,
+            themeApiMajor: THEME_API_MAJOR,
+          },
+          resolveInstalled: (listing) => {
+            const definition = marketplace.plugins.find((plugin) => plugin.key === listing.key)
+            return definition === undefined ? null : { enabled: true, version: definition.version }
+          },
+          notifyUpdate: marketplace.notifyUpdate,
+        })
+      },
+    })),
+
+    ...optional(deps.statistics, (statistics) => ({
+      async rollUpStatistics() {
+        const now = new Date()
+        const { memberCount } = await statistics.stats.rollUp(now)
+        const online = await statistics.presence.concurrentCount(now)
+        const record = await statistics.presence.recordIfHigher(online, now)
+        return { memberCount, online, record }
+      },
+    })),
+  }
+}
+
+function subscriptionNotifier(deps: TaskWorkerDeps): SubscriptionNotifier {
+  const wiring = deps.subscriptions!
+  return new SubscriptionNotifier({
+    subscriptions: wiring.repository,
+    forums: wiring.forums,
+    unsubscribeSecret: wiring.unsubscribeSecret,
+    notifications: {
+      async raise(input) {
+        await wiring.notifications.raise({
+          userId: input.userId,
+          kind: input.kind,
+          data: input.data as Parameters<NotificationService['raise']>[0]['data'],
+          href: input.href,
+          dedupeKey: input.dedupeKey,
+        })
+      },
+    },
+  })
+}
+
+function banPort(bans: BanService): {
+  ban: (input: {
+    userId: number
+    bannedByUserId: number
+    reason: string
+    publicReason: string
+    expiresAt?: Date | undefined
+  }) => Promise<void>
+} {
+  return {
+    async ban(input) {
+      await bans.ban(input)
+    },
+  }
+}

package/src/visible-forums.ts

@@ -0,0 +1,23 @@
+import type { ActorSource, Authorizer } from '@meith/authorization'
+import { logger } from '@meith/core'
+import type { VisibleForumSource } from '@meith/subscriptions'
+
+export function visibleForumSource(deps: {
+  readonly authorizer: Authorizer
+  readonly actors: ActorSource
+}): VisibleForumSource {
+  const log = logger({ module: 'subscriptions' })
+
+  return {
+    async visibleForumIdsFor(userId) {
+      try {
+        const actor = await deps.actors.buildForUser(userId)
+        if (actor === null) return []
+        return await deps.authorizer.visibleForumIds(actor)
+      } catch (err) {
+        log.warn({ err, userId }, 'could not resolve visible forums for a subscriber')
+        return []
+      }
+    },
+  }
+}