Worker- und PDF-Dienst

Der Worker hängt am Discord-Gateway und schreibt alle 30 Sekunden sein
Lebenszeichen in die Datenbank, damit /api/health im Web-Container den
Gateway-Zustand kennt, ohne selbst mit Discord zu sprechen. healthcheck.js
prüft genau dieses Lebenszeichen. Der eigentliche Rollen-Abgleich kommt in
Phase 1.

Der PDF-Dienst rendert die Druckansicht über Playwright. Kein PDF-Layout von
Hand, die Gestaltung kommt aus @media print der Seite selbst. Er kennt keine
Rechte: wer darf, entscheidet die Web-App, bevor sie hier anfragt, und schickt
das Sitzungs-Cookie des Abrufers mit, damit die gerenderte Seite dessen
Freigabestufe sieht.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

worker/eslint.config.mjs

@@ -0,0 +1,8 @@
+import js from '@eslint/js'
+import tseslint from 'typescript-eslint'
+
+export default tseslint.config(
+  { ignores: ['dist/**', 'node_modules/**'] },
+  js.configs.recommended,
+  ...tseslint.configs.recommended,
+)

worker/healthcheck.js

@@ -0,0 +1,39 @@
+// Healthcheck des Dienstes `worker`, wird vom Compose aufgerufen.
+// Prueft das eigene Lebenszeichen in der Datenbank: ist es frisch und meldet
+// `up`, gilt die Gateway-Verbindung als in Ordnung. Siehe docs/11-betrieb.md.
+// `pg` wird als CommonJS ausgeliefert, deshalb der Default-Import.
+import pg from 'pg'
+
+const { Client } = pg
+
+const MAX_AGE_MS = 120_000
+
+const client = new Client({ connectionString: process.env.DIRECT_DATABASE_URL ?? process.env.DATABASE_URL })
+
+try {
+  await client.connect()
+  const { rows } = await client.query(
+    'SELECT status, at FROM "ServiceHeartbeat" WHERE service = $1',
+    ['worker'],
+  )
+  const beat = rows[0]
+  if (!beat) {
+    console.error('kein Lebenszeichen')
+    process.exit(1)
+  }
+  const ageMs = Date.now() - new Date(beat.at).getTime()
+  if (ageMs > MAX_AGE_MS) {
+    console.error(`Lebenszeichen ${Math.round(ageMs / 1000)} s alt`)
+    process.exit(1)
+  }
+  if (beat.status !== 'up') {
+    console.error(`Zustand ${beat.status}`)
+    process.exit(1)
+  }
+  process.exit(0)
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error)
+  process.exit(1)
+} finally {
+  await client.end().catch(() => undefined)
+}

worker/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@afis/worker",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "build": "tsc -p tsconfig.build.json",
+    "lint": "eslint src --max-warnings 0",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests"
+  },
+  "dependencies": {
+    "@afis/db": "workspace:*",
+    "discord.js": "14.27.0",
+    "pg": "8.13.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.0",
+    "@types/node": "^22.10.0",
+    "@types/pg": "^8.11.10",
+    "eslint": "9.39.5",
+    "tsx": "4.20.6",
+    "typescript": "5.9.3",
+    "typescript-eslint": "^8.20.0",
+    "vitest": "4.1.11"
+  }
+}

worker/src/env.ts

@@ -0,0 +1,31 @@
+/**
+ * Der Worker teilt sich die .env mit der Web-App, braucht aber nur einen Teil
+ * davon. Fehlt etwas, stirbt der Prozess sofort mit klarer Meldung, damit der
+ * Fehler in Dockge am roten Container sichtbar wird und nicht im Lograuschen.
+ */
+export type WorkerEnv = {
+  databaseUrl: string
+  discordBotToken: string
+  discordGuildId: string
+  /** Voll-Abgleich als Sicherheitsnetz, siehe docs/02-architektur.md. */
+  fullSyncIntervalMs: number
+  heartbeatIntervalMs: number
+  adminChannelId?: string
+}
+
+function required(name: string): string {
+  const value = process.env[name]
+  if (!value) throw new Error(`Konfiguration unvollständig: ${name} fehlt`)
+  return value
+}
+
+export function loadEnv(): WorkerEnv {
+  return {
+    databaseUrl: required('DATABASE_URL'),
+    discordBotToken: required('DISCORD_BOT_TOKEN'),
+    discordGuildId: required('DISCORD_GUILD_ID'),
+    fullSyncIntervalMs: Number(process.env.WORKER_FULL_SYNC_MS ?? 5 * 60_000),
+    heartbeatIntervalMs: Number(process.env.WORKER_HEARTBEAT_MS ?? 30_000),
+    adminChannelId: process.env.DISCORD_ADMIN_CHANNEL_ID,
+  }
+}

worker/src/heartbeat.ts

@@ -0,0 +1,20 @@
+import type { PrismaClient } from '@afis/db'
+
+export type HeartbeatStatus = 'up' | 'degraded' | 'down'
+
+/**
+ * Der Worker schreibt sein Lebenszeichen in die Datenbank, damit /api/health im
+ * Web-Container den Gateway-Zustand kennt, ohne selbst mit Discord zu sprechen.
+ * Siehe docs/11-betrieb.md.
+ */
+export async function writeHeartbeat(
+  db: PrismaClient,
+  status: HeartbeatStatus,
+  detail?: string,
+): Promise<void> {
+  await db.serviceHeartbeat.upsert({
+    where: { service: 'worker' },
+    create: { service: 'worker', status, detail: detail ?? null },
+    update: { status, detail: detail ?? null, at: new Date() },
+  })
+}

worker/src/index.ts

@@ -0,0 +1,72 @@
+import { Client, GatewayIntentBits, Events } from 'discord.js'
+import { createPrismaClient } from '@afis/db'
+import { loadEnv } from './env.js'
+import { writeHeartbeat } from './heartbeat.js'
+
+/**
+ * Rollen-Abgleich-Worker. Haengt am Discord-Gateway und haelt die
+ * Guild-Mitgliedschaft in Postgres aktuell, damit die Web-App nie live bei
+ * Discord anfragen muss. Siehe docs/02-architektur.md.
+ *
+ * Phase 0 baut das Geruest: Verbindung, Lebenszeichen, sauberes Herunterfahren.
+ * Der eigentliche Abgleich (Ereignisse, Voll-Abgleich, pg_notify) kommt in Phase 1.
+ */
+async function main(): Promise<void> {
+  const env = loadEnv()
+  const db = createPrismaClient(env.databaseUrl)
+
+  const client = new Client({
+    // Server Members Intent muss im Developer Portal aktiviert sein, sonst
+    // liefert der Bot keine Rollen. Siehe docs/03-auth-und-rechte.md.
+    intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMembers],
+  })
+
+  let gatewayReady = false
+
+  client.once(Events.ClientReady, (ready) => {
+    gatewayReady = true
+    console.log(`[worker] am Gateway als ${ready.user.tag}`)
+  })
+
+  client.on(Events.ShardDisconnect, (_event, shardId) => {
+    gatewayReady = false
+    console.warn(`[worker] Verbindung zu Shard ${shardId} verloren`)
+  })
+
+  client.on(Events.ShardResume, () => {
+    gatewayReady = true
+    console.log('[worker] Verbindung wiederhergestellt')
+  })
+
+  client.on(Events.Error, (error) => {
+    console.error('[worker] Gateway-Fehler', error)
+  })
+
+  const heartbeat = setInterval(() => {
+    void writeHeartbeat(
+      db,
+      gatewayReady ? 'up' : 'degraded',
+      gatewayReady ? undefined : 'Gateway nicht verbunden',
+    ).catch((error: unknown) => console.error('[worker] Lebenszeichen fehlgeschlagen', error))
+  }, env.heartbeatIntervalMs)
+
+  async function shutdown(signal: string): Promise<void> {
+    console.log(`[worker] ${signal}, fahre herunter`)
+    clearInterval(heartbeat)
+    await writeHeartbeat(db, 'down', 'planmäßig beendet').catch(() => undefined)
+    await client.destroy()
+    await db.$disconnect()
+    process.exit(0)
+  }
+
+  process.on('SIGTERM', () => void shutdown('SIGTERM'))
+  process.on('SIGINT', () => void shutdown('SIGINT'))
+
+  await writeHeartbeat(db, 'degraded', 'Start läuft')
+  await client.login(env.discordBotToken)
+}
+
+main().catch((error: unknown) => {
+  console.error('[worker] Start fehlgeschlagen', error)
+  process.exit(1)
+})

worker/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "declaration": false,
+    "sourceMap": true
+  }
+}

worker/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"]
+}