@meith/board-digest 0.32.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jordan Harrison and the Meith contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@meith/board-digest",
+  "version": "0.32.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/meith-dev/meith.git",
+    "directory": "packages/board-digest"
+  },
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "files": [
+    "src",
+    "!src/**/*.test.*",
+    "!src/**/*.type-test.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@meith/core": "0.32.0",
+    "@meith/subscriptions": "0.32.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+export {
+  BOARD_DIGEST_CADENCE_INTERVAL_MS,
+  BOARD_DIGEST_CADENCES,
+  BOARD_DIGEST_DEFAULT_CADENCE,
+  type BoardDigestCadence,
+  isBoardDigestCadence,
+  parseBoardDigestCadence,
+} from './modes'
+export {
+  BoardDigestNotifier,
+  MAX_MEMBERS_PER_RUN,
+  MAX_THREADS_CONSIDERED,
+  MAX_THREADS_IN_BOARD_DIGEST,
+  type RunOutcome,
+} from './notifier'
+export type {
+  BoardDigestContentSource,
+  BoardDigestNotifierPort,
+  BoardDigestRepository,
+  BoardDigestThread,
+  EligibleMember,
+} from './types'

package/src/modes.ts

@@ -0,0 +1,18 @@
+export const BOARD_DIGEST_CADENCES = ['weekly', 'monthly'] as const
+
+export type BoardDigestCadence = (typeof BOARD_DIGEST_CADENCES)[number]
+
+export const BOARD_DIGEST_DEFAULT_CADENCE: BoardDigestCadence = 'weekly'
+
+export const BOARD_DIGEST_CADENCE_INTERVAL_MS: Readonly<Record<BoardDigestCadence, number>> = {
+  weekly: 7 * 24 * 60 * 60 * 1000,
+  monthly: 30 * 24 * 60 * 60 * 1000,
+}
+
+export function isBoardDigestCadence(value: string): value is BoardDigestCadence {
+  return (BOARD_DIGEST_CADENCES as readonly string[]).includes(value)
+}
+
+export function parseBoardDigestCadence(value: string): BoardDigestCadence | null {
+  return isBoardDigestCadence(value) ? value : null
+}

package/src/notifier.ts

@@ -0,0 +1,109 @@
+import { mintUnsubscribeToken } from '@meith/subscriptions'
+
+import { BOARD_DIGEST_CADENCE_INTERVAL_MS, type BoardDigestCadence } from './modes'
+import type {
+  BoardDigestContentSource,
+  BoardDigestNotifierPort,
+  BoardDigestRepository,
+  BoardDigestThread,
+} from './types'
+
+export const MAX_MEMBERS_PER_RUN = 50
+
+export const MAX_THREADS_CONSIDERED = 50
+
+export const MAX_THREADS_IN_BOARD_DIGEST = 10
+
+const DAY_MS = 24 * 60 * 60 * 1000
+
+export interface RunOutcome {
+  readonly notified: number
+  readonly considered: number
+}
+
+export class BoardDigestNotifier {
+  private readonly repository: BoardDigestRepository
+  private readonly content: BoardDigestContentSource
+  private readonly notifications: BoardDigestNotifierPort
+  private readonly secret: string | null
+  private readonly now: () => Date
+
+  constructor(deps: {
+    repository: BoardDigestRepository
+    content: BoardDigestContentSource
+    notifications: BoardDigestNotifierPort
+    unsubscribeSecret?: string | null
+    now?: () => Date
+  }) {
+    this.repository = deps.repository
+    this.content = deps.content
+    this.notifications = deps.notifications
+    this.secret = deps.unsubscribeSecret ?? null
+    this.now = deps.now ?? (() => new Date())
+  }
+
+  async run(
+    cadence: BoardDigestCadence,
+    lapsedThresholdDays: number,
+    limit = MAX_MEMBERS_PER_RUN,
+    signal?: AbortSignal,
+  ): Promise<RunOutcome> {
+    const at = this.now()
+    const dueBefore = new Date(at.getTime() - BOARD_DIGEST_CADENCE_INTERVAL_MS[cadence])
+    const lapsedBefore = new Date(at.getTime() - lapsedThresholdDays * DAY_MS)
+
+    const members = await this.repository.dueMembers({ cadence, dueBefore, lapsedBefore, limit })
+
+    let notified = 0
+    let considered = 0
+
+    for (const member of members) {
+      if (signal?.aborted === true) break
+      considered += 1
+
+      try {
+        const threads = await this.content.threadsActiveSince(
+          member.userId,
+          member.lastActiveAt,
+          MAX_THREADS_CONSIDERED,
+        )
+        if (threads.length === 0) continue
+
+        await this.notifications.raise({
+          userId: member.userId,
+          kind: 'board.digest',
+          data: {
+            cadence,
+            threadCount: threads.length,
+            threads: threads.slice(0, MAX_THREADS_IN_BOARD_DIGEST).map(threadPayload),
+            more: Math.max(0, threads.length - MAX_THREADS_IN_BOARD_DIGEST),
+            unsubscribe: this.token(member.userId),
+          },
+          href: '/notifications/preferences',
+          dedupeKey: null,
+        })
+
+        await this.repository.recordDigestRun({ userId: member.userId, at })
+        notified += 1
+      } catch {}
+    }
+
+    return { notified, considered }
+  }
+
+  private token(userId: number): string | null {
+    return this.secret === null
+      ? null
+      : mintUnsubscribeToken({ userId, scope: 'board-digest', targetId: 0 }, this.secret)
+  }
+}
+
+function threadPayload(thread: BoardDigestThread): Record<string, unknown> {
+  return {
+    title: thread.title,
+    href: thread.href,
+    forumTitle: thread.forumTitle,
+    replyCount: thread.replyCount,
+    lastAuthor: thread.lastAuthor,
+  }
+}

package/src/types.ts

@@ -0,0 +1,44 @@
+import type { BoardDigestCadence } from './modes'
+
+export interface BoardDigestThread {
+  readonly threadId: number
+  readonly title: string
+  readonly href: string
+  readonly forumTitle: string
+  readonly replyCount: number
+  readonly lastAuthor: string | null
+}
+
+export interface EligibleMember {
+  readonly userId: number
+  readonly lastActiveAt: Date
+}
+
+export interface BoardDigestRepository {
+  dueMembers(input: {
+    readonly cadence: BoardDigestCadence
+    readonly dueBefore: Date
+    readonly lapsedBefore: Date
+    readonly limit: number
+  }): Promise<readonly EligibleMember[]>
+
+  recordDigestRun(input: { readonly userId: number; readonly at: Date }): Promise<void>
+}
+
+export interface BoardDigestContentSource {
+  threadsActiveSince(
+    userId: number,
+    since: Date,
+    limit: number,
+  ): Promise<readonly BoardDigestThread[]>
+}
+
+export interface BoardDigestNotifierPort {
+  raise(input: {
+    readonly userId: number
+    readonly kind: 'board.digest'
+    readonly data: Record<string, unknown>
+    readonly href: string | null
+    readonly dedupeKey: string | null
+  }): Promise<void>
+}