Phase 6 abgeschlossen: Aktenchat, Kanäle, Echtzeit, Benachrichtigungen
Ein Ereignisstrom mit Themen (/api/stream), in dem der Dateistrom aus Phase 5 aufgegangen ist. Zwei Prüfungen: beim Verbinden, welche Themen der Nutzer abonnieren darf, und je Ereignis wird der Inhalt mit seinen Rechten geladen. Das zweite ist nicht nur Vorsicht — eine Umklassifizierung wirkt dadurch in einer offenen Verbindung sofort. In der pg_notify-Nutzlast steht nie ein Inhalt, nur Thema, Art und Kennung. Der Aktenchat sendet optimistisch mit clientseitiger UUIDv7, die zugleich Idempotenzschlüssel ist. Antworten, vier feste Reaktionen, Bearbeiten mit sichtbarem editedAt, Zurückziehen mit Platzhalter — Löschen gibt es nicht, und eine Regel in der Datenbank hält das fest. Eine zurückgezogene Nachricht kommt ohne Text an, nicht ausgeblendet. Aktenzeichen im Text werden zu Vorschaukarten, serverseitig aufgelöst. Eine Akte, die der Leser nicht sehen darf, sieht darin genauso aus wie eine, die es gar nicht gibt. "Als Vermerk übernehmen" steht sichtbar an jeder Nachricht. Der Vermerk gehört dem Verfasser, nicht dem Übernehmenden; ein Systemeintrag nennt den Ursprung, damit der Wortlaut später nicht für die Akte geschrieben wirkt. Bei den Discord-Benachrichtigungen entscheidet die Web-App, wer was erfährt, und der Worker liefert nur aus. Die Alternative hätte geheissen, die Sichtbarkeitsprüfung im Worker ein zweites Mal zu bauen. In meta steht ein Titel nur, wenn er hinaus darf — ab Stufe 3 keiner. Postausgang als Tabelle, angestossen über LISTEN, mit Takt als Sicherheitsnetz. Nebenbei riss das Budget der Fallakte erneut (122 kB). Drei Schritte zurück auf 119,6: Chattexte in eine eigene i18n-Datei, ein gemeinsames AddPanel statt viermal derselbe Aufklapp-Code, und eine eigene UUIDv7 statt des Pakets — die Sortierbarkeit, auf der die Nachlieferung beruht, steht damit im eigenen Code und hat Tests. Unterwegs habe ich NotifyMode und User.notifyMode ein zweites Mal angelegt, obwohl es beides seit dem Grundgerüst gibt. Die Migration schlug fehl und die Datenbank musste von Hand aufgeräumt werden; die Lehre steht in docs/13. 155 Tests im Web-Paket, 15 in der Datenbank, 7 im Worker, 32 e2e.
This commit is contained in:
Harlekin
@@ -0,0 +1,311 @@
|
||||
import { getCurrentUser, type CurrentUser } from '@/lib/auth/current'
|
||||
import { db } from '@/lib/db'
|
||||
import { visibleCaseWhere } from '@/lib/access/caseFilter'
|
||||
import { visibleChannelWhere, visibleMessageWhere } from '@/lib/access/chatFilter'
|
||||
import { visibleAttachmentWhere } from '@/lib/access/attachmentFilter'
|
||||
import { resolveCasePreviews, type CasePreview } from '@/lib/chat/preview'
|
||||
import { extractCaseNumbers, type ChatMessageView } from '@/lib/chat/view'
|
||||
import { ensureListening, subscribe } from '@/lib/realtime/listener'
|
||||
import type { StreamEvent, Topic } from '@/lib/realtime/publish'
|
||||
|
||||
export const runtime = 'nodejs'
|
||||
export const dynamic = 'force-dynamic'
|
||||
|
||||
/** Gegen Zwischenspeicher und Tunnel, die eine stille Verbindung für tot halten. */
|
||||
const HEARTBEAT_MS = 25_000
|
||||
|
||||
/**
|
||||
* Ereignisstrom für offene Ansichten.
|
||||
*
|
||||
* GET /api/stream?topics=case:<id>,channel:<id>
|
||||
*
|
||||
* Server-Sent Events und kein WebSocket: die Richtung ist einseitig, es geht
|
||||
* durch jeden Tunnel, und der Browser baut die Verbindung von selbst wieder
|
||||
* auf. Siehe docs/06-chat-und-realtime.md.
|
||||
*
|
||||
* Zwei Prüfungen, beide nötig:
|
||||
* 1. **Beim Verbinden**: welche der angefragten Themen darf dieser Nutzer
|
||||
* überhaupt abonnieren. Wer ein fremdes Thema nennt, bekommt es nicht —
|
||||
* und erfährt auch nicht, ob es existiert.
|
||||
* 2. **Je Ereignis**: der Inhalt wird mit den Rechten des Empfängers geladen.
|
||||
* Eine Umklassifizierung mitten in einer offenen Verbindung wirkt dadurch
|
||||
* sofort, ohne dass jemand neu laden muss.
|
||||
*/
|
||||
export async function GET(request: Request): Promise<Response> {
|
||||
const user = await getCurrentUser()
|
||||
if (!user) return new Response(null, { status: 404 })
|
||||
|
||||
const url = new URL(request.url)
|
||||
const gewuenscht = (url.searchParams.get('topics') ?? '')
|
||||
.split(',')
|
||||
.map((t) => t.trim())
|
||||
.filter(Boolean)
|
||||
.slice(0, 20)
|
||||
|
||||
const erlaubt = await erlaubteThemen(user, gewuenscht)
|
||||
await ensureListening()
|
||||
|
||||
const encoder = new TextEncoder()
|
||||
let heartbeat: ReturnType<typeof setInterval> | null = null
|
||||
let unsubscribe: (() => void) | null = null
|
||||
let offen = true
|
||||
|
||||
const stream = new ReadableStream({
|
||||
async start(controller) {
|
||||
const send = (event: string, data: unknown, id?: string) => {
|
||||
if (!offen) return
|
||||
try {
|
||||
const zeilen = [
|
||||
...(id ? [`id: ${id}`] : []),
|
||||
`event: ${event}`,
|
||||
`data: ${JSON.stringify(data)}`,
|
||||
'',
|
||||
'',
|
||||
]
|
||||
controller.enqueue(encoder.encode(zeilen.join('\n')))
|
||||
} catch {
|
||||
offen = false
|
||||
}
|
||||
}
|
||||
|
||||
// Verpasstes nachliefern. Der Browser schickt beim Wiederverbinden von
|
||||
// selbst die zuletzt gesehene Kennung mit; die Kennungen sind UUIDv7 und
|
||||
// damit zeitlich sortiert, ein Vergleich darauf reicht.
|
||||
const seit = request.headers.get('last-event-id') ?? url.searchParams.get('since')
|
||||
if (seit) await nachliefern(user, erlaubt, seit, send)
|
||||
|
||||
send('ready', { topics: erlaubt })
|
||||
|
||||
heartbeat = setInterval(() => {
|
||||
if (!offen) return
|
||||
try {
|
||||
controller.enqueue(encoder.encode(': ping\n\n'))
|
||||
} catch {
|
||||
offen = false
|
||||
}
|
||||
}, HEARTBEAT_MS)
|
||||
|
||||
unsubscribe = subscribe((event) => {
|
||||
if (!erlaubt.includes(event.t)) return
|
||||
void zustellen(user, event, send)
|
||||
})
|
||||
|
||||
request.signal.addEventListener('abort', () => {
|
||||
offen = false
|
||||
try {
|
||||
controller.close()
|
||||
} catch {
|
||||
// schon zu
|
||||
}
|
||||
})
|
||||
},
|
||||
cancel() {
|
||||
offen = false
|
||||
if (heartbeat) clearInterval(heartbeat)
|
||||
unsubscribe?.()
|
||||
},
|
||||
})
|
||||
|
||||
return new Response(stream, {
|
||||
headers: {
|
||||
'Content-Type': 'text/event-stream; charset=utf-8',
|
||||
'Cache-Control': 'no-cache, no-transform',
|
||||
Connection: 'keep-alive',
|
||||
// Der Tunnel darf nicht puffern, sonst kommt alles am Stück.
|
||||
'X-Accel-Buffering': 'no',
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
/**
|
||||
* Filtert die angefragten Themen auf die, die der Nutzer sehen darf.
|
||||
*
|
||||
* Das eigene Nutzerthema ist immer dabei, alles andere muss belegt werden.
|
||||
*/
|
||||
async function erlaubteThemen(user: CurrentUser, gewuenscht: string[]): Promise<Topic[]> {
|
||||
const themen: Topic[] = [`user:${user.id}`]
|
||||
|
||||
const fallIds = gewuenscht
|
||||
.filter((t) => t.startsWith('case:'))
|
||||
.map((t) => t.slice(5))
|
||||
.filter(Boolean)
|
||||
const kanalIds = gewuenscht
|
||||
.filter((t) => t.startsWith('channel:'))
|
||||
.map((t) => t.slice(8))
|
||||
.filter(Boolean)
|
||||
|
||||
if (fallIds.length > 0) {
|
||||
const sichtbar = await db.case.findMany({
|
||||
where: { AND: [visibleCaseWhere(user.permissions), { id: { in: fallIds } }] },
|
||||
select: { id: true },
|
||||
})
|
||||
themen.push(...sichtbar.map((akte) => `case:${akte.id}` as Topic))
|
||||
}
|
||||
|
||||
if (kanalIds.length > 0) {
|
||||
const sichtbar = await db.channel.findMany({
|
||||
where: { AND: [visibleChannelWhere(user.permissions), { id: { in: kanalIds } }] },
|
||||
select: { id: true },
|
||||
})
|
||||
themen.push(...sichtbar.map((kanal) => `channel:${kanal.id}` as Topic))
|
||||
}
|
||||
|
||||
return themen
|
||||
}
|
||||
|
||||
type Send = (event: string, data: unknown, id?: string) => void
|
||||
|
||||
/** Was seit `seit` in den abonnierten Themen passiert ist. */
|
||||
async function nachliefern(
|
||||
user: CurrentUser,
|
||||
themen: Topic[],
|
||||
seit: string,
|
||||
send: Send,
|
||||
): Promise<void> {
|
||||
const fallIds = themen.filter((t) => t.startsWith('case:')).map((t) => t.slice(5))
|
||||
const kanalIds = themen.filter((t) => t.startsWith('channel:')).map((t) => t.slice(8))
|
||||
if (fallIds.length === 0 && kanalIds.length === 0) return
|
||||
|
||||
try {
|
||||
const verpasst = await db.chatMessage.findMany({
|
||||
where: {
|
||||
AND: [
|
||||
visibleMessageWhere(user.permissions),
|
||||
{ id: { gt: seit } },
|
||||
{ OR: [{ caseId: { in: fallIds } }, { channelId: { in: kanalIds } }] },
|
||||
],
|
||||
},
|
||||
orderBy: { id: 'asc' },
|
||||
take: 200,
|
||||
select: NACHRICHT,
|
||||
})
|
||||
|
||||
for (const angereichert of await anreichern(user, verpasst)) {
|
||||
send('chat.new', angereichert, angereichert.id)
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('[stream] Nachlieferung fehlgeschlagen', error)
|
||||
}
|
||||
}
|
||||
|
||||
const NACHRICHT = {
|
||||
id: true,
|
||||
body: true,
|
||||
authorId: true,
|
||||
replyToId: true,
|
||||
editedAt: true,
|
||||
withdrawnAt: true,
|
||||
adoptedEntryId: true,
|
||||
mentions: true,
|
||||
createdAt: true,
|
||||
caseId: true,
|
||||
channelId: true,
|
||||
} as const
|
||||
|
||||
/**
|
||||
* Ergänzt, was die Anzeige braucht und was **je Empfänger verschieden** ist:
|
||||
* den Namen des Autors und die Vorschaukarten zu erwähnten Aktenzeichen. Die
|
||||
* Karten werden mit den Rechten des Empfängers aufgelöst, deshalb hier und
|
||||
* nicht beim Absender.
|
||||
*/
|
||||
function vorschauenFuer(
|
||||
body: string,
|
||||
alle: Map<string, CasePreview>,
|
||||
): Record<string, CasePreview> {
|
||||
const treffer: Record<string, CasePreview> = {}
|
||||
for (const nummer of extractCaseNumbers(body)) {
|
||||
const vorschau = alle.get(nummer)
|
||||
if (vorschau) treffer[nummer] = vorschau
|
||||
}
|
||||
return treffer
|
||||
}
|
||||
|
||||
async function anreichern(
|
||||
user: CurrentUser,
|
||||
nachrichten: {
|
||||
id: string
|
||||
body: string
|
||||
authorId: string
|
||||
replyToId: string | null
|
||||
editedAt: Date | null
|
||||
withdrawnAt: Date | null
|
||||
adoptedEntryId: string | null
|
||||
mentions: string[]
|
||||
createdAt: Date
|
||||
}[],
|
||||
): Promise<ChatMessageView[]> {
|
||||
if (nachrichten.length === 0) return []
|
||||
|
||||
const [autoren, vorschauen] = await Promise.all([
|
||||
db.user.findMany({
|
||||
where: { id: { in: [...new Set(nachrichten.map((n) => n.authorId))] } },
|
||||
select: { id: true, displayName: true, username: true },
|
||||
}),
|
||||
resolveCasePreviews(
|
||||
user.permissions,
|
||||
nachrichten.flatMap((n) => extractCaseNumbers(n.body)),
|
||||
),
|
||||
])
|
||||
const nameVon = new Map(autoren.map((a) => [a.id, a.displayName]))
|
||||
|
||||
return nachrichten.map((nachricht) => ({
|
||||
id: nachricht.id,
|
||||
body: nachricht.withdrawnAt ? '' : nachricht.body,
|
||||
authorId: nachricht.authorId,
|
||||
authorName: nameVon.get(nachricht.authorId) ?? nachricht.authorId,
|
||||
replyToId: nachricht.replyToId,
|
||||
editedAt: nachricht.editedAt?.toISOString() ?? null,
|
||||
withdrawnAt: nachricht.withdrawnAt?.toISOString() ?? null,
|
||||
adoptedEntryId: nachricht.adoptedEntryId,
|
||||
createdAt: nachricht.createdAt.toISOString(),
|
||||
previews: vorschauenFuer(nachricht.body, vorschauen),
|
||||
}))
|
||||
}
|
||||
|
||||
/**
|
||||
* Lädt den Inhalt zu einem Ereignis **mit den Rechten des Empfängers**.
|
||||
*
|
||||
* Findet die Abfrage nichts, wird nichts geschickt: weder Inhalt noch die
|
||||
* Kennung. Sonst verriete schon die Kennung, dass es etwas gibt.
|
||||
*/
|
||||
async function zustellen(user: CurrentUser, event: StreamEvent, send: Send): Promise<void> {
|
||||
try {
|
||||
if (event.k.startsWith('chat.')) {
|
||||
const nachricht = await db.chatMessage.findFirst({
|
||||
where: { AND: [visibleMessageWhere(user.permissions), { id: event.i }] },
|
||||
select: NACHRICHT,
|
||||
})
|
||||
if (!nachricht) return
|
||||
const [angereichert] = await anreichern(user, [nachricht])
|
||||
if (angereichert) send(event.k, angereichert, angereichert.id)
|
||||
return
|
||||
}
|
||||
|
||||
if (event.k === 'attachment.scanned') {
|
||||
const anhang = await db.attachment.findFirst({
|
||||
where: { AND: [visibleAttachmentWhere(user.permissions), { id: event.i }] },
|
||||
select: {
|
||||
id: true,
|
||||
scanStatus: true,
|
||||
scanMessage: true,
|
||||
mimeType: true,
|
||||
sizeBytes: true,
|
||||
thumbKey: true,
|
||||
blurhash: true,
|
||||
width: true,
|
||||
height: true,
|
||||
},
|
||||
})
|
||||
if (anhang) {
|
||||
send('attachment.scanned', { ...anhang, hasThumb: anhang.thumbKey !== null, thumbKey: undefined })
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Verlaufseinträge und Kopfdaten: nur die Kennung. Die Ansicht lädt
|
||||
// daraufhin nach, statt dass hier ein zweiter Renderpfad entsteht.
|
||||
send(event.k, { id: event.i })
|
||||
} catch (error) {
|
||||
console.error('[stream] Ereignis nicht zugestellt', error)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user