@meith/tasks 0.30.1 → 0.32.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meith/tasks",
-  "version": "0.30.1",
+  "version": "0.32.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -10,6 +10,9 @@
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
+  "dependencies": {
+    "@meith/core": "^0.32.0"
+  },
   "files": [
     "src",
     "!src/**/*.test.*",

package/src/builtin.ts

@@ -24,6 +24,7 @@ export interface TaskWorkers {
   expireWarnings(batchSize: number): Promise<number>
   notifySubscribers(batchSize: number, signal: AbortSignal): Promise<number>
   sendDigests(batchSize: number, signal: AbortSignal): Promise<number>
+  sendBoardDigests(batchSize: number, signal: AbortSignal): Promise<number>
   sweepAttachments(batchSize: number): Promise<{ deleted: number; failed: number }>
   sweepAvatars(batchSize: number): Promise<number>
   rollUpStatistics(): Promise<{ memberCount: number; online: number; record: boolean }>
@@ -361,6 +362,26 @@ function allDefinitions(workers: TaskWorkers): TaskDefinition[] {
       },
     },
 
+    {
+      id: 'board.digest_send',
+      title: 'Send board activity digests',
+      titleKey: 'adminSystem.task.boardDigestSend.title',
+      description:
+        'Sends the recap a member opted into after they have been away long enough to ' +
+        'count as lapsed, and only once their own cadence — weekly or monthly — is due. ' +
+        'Content is fetched per recipient through the same permission filter as the rest ' +
+        'of the board, so a digest never names a thread its reader could not open. Hourly, ' +
+        'for the same reason the subscription digest is: a due check is a query that finds ' +
+        'nobody most of the time.',
+      descriptionKey: 'adminSystem.task.boardDigestSend.description',
+      intervalSeconds: 3_600,
+      maxDurationSeconds: 60,
+      async run({ signal }) {
+        const notified = await workers.sendBoardDigests(50, signal)
+        return { detail: { notified } }
+      },
+    },
+
     {
       id: 'attachments.sweep',
       title: 'Collect abandoned attachment files',
@@ -446,6 +467,7 @@ const REQUIRED_WORKER: Readonly<Record<string, keyof TaskWorkers>> = {
   'warnings.expire': 'expireWarnings',
   'subscriptions.instant': 'notifySubscribers',
   'subscriptions.digest': 'sendDigests',
+  'board.digest_send': 'sendBoardDigests',
   'attachments.sweep': 'sweepAttachments',
   'avatars.sweep': 'sweepAvatars',
   'stats.rollup': 'rollUpStatistics',

package/src/scheduler.ts

@@ -1,3 +1,5 @@
+import { type CronSchedule, nextRun, parseCron } from '@meith/core'
+
 import type { TaskContext, TaskDefinition, TaskResult } from './types'
 
 export interface TaskRepository {
@@ -13,9 +15,17 @@ export interface TaskRepository {
     success: boolean
     detail?: Record<string, unknown>
     error?: string
+    nextRunAt?: Date
   }): Promise<void>
 
-  ensureRegistered(tasks: readonly { id: string; intervalSeconds: number }[]): Promise<void>
+  ensureRegistered(
+    tasks: readonly {
+      id: string
+      intervalSeconds: number
+      schedule?: string
+      firstRunAt?: Date
+    }[],
+  ): Promise<void>
 }
 
 export interface TickOutcome {
@@ -44,8 +54,35 @@ export async function tick({
   onError,
   signal,
 }: TickDeps): Promise<TickOutcome[]> {
+  const schedules = new Map<string, { expression: string; parsed: CronSchedule }>()
+  const broken = new Map<string, string>()
+  for (const task of tasks) {
+    if (task.schedule === undefined) continue
+    try {
+      const parsed = parseCron(task.schedule)
+      nextRun(parsed, now)
+      schedules.set(task.id, { expression: task.schedule, parsed })
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      broken.set(task.id, message)
+      onError?.(task.id, error)
+    }
+  }
+
   await repository.ensureRegistered(
-    tasks.map((t) => ({ id: t.id, intervalSeconds: t.intervalSeconds })),
+    tasks
+      .filter((t) => !broken.has(t.id))
+      .map((t) => {
+        const entry = schedules.get(t.id)
+        return entry === undefined
+          ? { id: t.id, intervalSeconds: t.intervalSeconds }
+          : {
+              id: t.id,
+              intervalSeconds: t.intervalSeconds,
+              schedule: entry.expression,
+              firstRunAt: nextRun(entry.parsed, now),
+            }
+      }),
   )
 
   const outcomes: TickOutcome[] = []
@@ -54,6 +91,12 @@ export async function tick({
   for (const task of tasks) {
     const startedAt = Date.now()
 
+    const brokenReason = broken.get(task.id)
+    if (brokenReason !== undefined) {
+      outcomes.push({ taskId: task.id, status: 'failed', durationMs: 0, error: brokenReason })
+      continue
+    }
+
     if (signal?.aborted === true) {
       outcomes.push({ taskId: task.id, status: 'skipped', durationMs: 0 })
       continue
@@ -88,11 +131,15 @@ export async function tick({
 
       const result: TaskResult = await task.run(context)
 
+      const finishedAt = elapsedSince()
+      const entry = schedules.get(task.id)
+
       await repository.release({
         taskId: task.id,
-        finishedAt: elapsedSince(),
+        finishedAt,
         success: true,
         ...(result.detail ? { detail: result.detail } : {}),
+        ...(entry ? { nextRunAt: nextRun(entry.parsed, finishedAt) } : {}),
       })
 
       outcomes.push({
@@ -106,11 +153,15 @@ export async function tick({
       const message = error instanceof Error ? error.message : String(error)
       onError?.(task.id, error)
 
+      const finishedAt = elapsedSince()
+      const entry = schedules.get(task.id)
+
       await repository.release({
         taskId: task.id,
-        finishedAt: elapsedSince(),
+        finishedAt,
         success: false,
         error: message,
+        ...(entry ? { nextRunAt: nextRun(entry.parsed, finishedAt) } : {}),
       })
 
       outcomes.push({

package/src/types.ts

@@ -16,6 +16,7 @@ export interface TaskDefinition {
   readonly titleKey?: string
   readonly descriptionKey?: string
   readonly intervalSeconds: number
+  readonly schedule?: string
   readonly maxDurationSeconds: number
   run(context: TaskContext): Promise<TaskResult>
 }