Talk to PostgreSQL directly, and let the pooled connection forget

Zweiter Schritt weg von Supabase. Sämtliche 49 Lesezugriffe und alle
Mutationen laufen jetzt über lib/db statt über die REST-Schicht: Kysely auf
einem pg-Pool, jede Abfrage in einer Transaktion, in der zuerst
app.user_id gesetzt wird. Die Anmeldung hängt noch an GoTrue — sie liefert
die Kennung, die in withUser() geht. Damit war der Umbau in zwei Hälften
teilbar und die Anwendung durchgehend lauffähig.

Was dabei ersatzlos verschwindet:

  - fetchAllRows. Es gab die Funktion nur, weil PostgREST jede Antwort bei
    1000 Zeilen still abschneidet und ein Bericht dann leise falsch war.
    Am direkten Zugang ist eine Abfrage eine Abfrage.
  - sanitizeIlikeTerm samt Test. Sie entschärfte Zeichen, die in der
    Filtersyntax strukturelle Bedeutung hatten; jetzt wird der Suchbegriff
    als Parameter gebunden und ein Komma ist ein Komma. Die Lücke ist nicht
    abgesichert, sondern weg.
  - lib/supabase/admin.ts. Der Dienstschlüssel, der RLS aushebelte, hatte
    genau einen Aufrufer — den nächtlichen Lauf. Der benutzt jetzt dieselbe
    Rolle ohne BYPASSRLS und ruft eine SECURITY-DEFINER-Funktion auf, die
    selbst prüft, was sie tut. Es gibt keinen privilegierten Zugang mehr.

Nebenbei besser geworden, weil der direkte Zugang es erlaubt:

  - Eine Seite ist eine Transaktion. Das Layout etwa liest Profil,
    Planstellen, Standorte, Entwürfe und Notizen auf einem einheitlichen
    Lesestand statt in fünf unabhängigen Anfragen.
  - Der Bereichsfilter der Mitarbeiterliste ist ein EXISTS statt einer
    eingebetteten Ressource mit !inner — eine Person mit mehreren
    Zuordnungen über die Zeit erschien dort mehrfach.
  - Seitenweise Listen sortieren zusätzlich nach id. Bei gleichem Nachnamen
    oder gleichem Zeitstempel war die Reihenfolge vorher unbestimmt, und
    dieselbe Zeile konnte auf zwei Seiten erscheinen oder auf keiner.
  - Angehörige werden in der Datenbank gezählt statt alle Zeilen zu holen.
  - Namen an Ereigniszeilen kommen aus einem Join statt aus einem
    Nachschlag, der ausserhalb der Transaktion lag.

Der Statusfilter ist mitgezogen: dieselbe Regel wie deriveStatusAsOf,
Klausel für Klausel, jetzt als Kysely-Ausdruck. Der Integrationstest, der
beide über den gesamten Bestand vergleicht, läuft weiter — mit eigener
Verbindung, denn geprüft wird die Bedingung, nicht die Berechtigung.

Zwei Fehler auf dem Weg, beide vom Typprüfer gefangen: apply_due_pending_
changes() nimmt kein Argument, wurde von callFunction aber mit jsonb
aufgerufen — Postgres hätte keine passende Signatur gefunden. Und der
Sicherheitstest lädt jetzt Module mit `import "server-only"`, was ausserhalb
der Server-Übersetzung wirft.

Typecheck, Lint, Build und 180 Tests sind grün. Ungeprüft bleibt der Lauf
gegen eine echte Datenbank — dafür fehlt eine DATABASE_URL.

app/api/export/report/route.ts

@@ -24,59 +24,64 @@ import {
   type ReportRow,
 } from "@/lib/reports";
 import { loadEventHistory, loadOrgLookups, loadSnapshotEmployees } from "@/lib/reports-data";
-import { requireHrUser } from "@/lib/supabase/auth";
-import { createClient } from "@/lib/supabase/server";
+import { requireHrUser } from "@/lib/auth/require-hr";
+import { withUser } from "@/lib/db";
 
 // Exports exactly the pivot table currently on screen (same mode/measure or
 // event-type/group/split/filters, read from the query string the client
 // already keeps in the URL) as a flat table — one row per group, one column
 // per split value if a split is active.
 export async function GET(request: NextRequest) {
-  const supabase = await createClient();
-  const denied = await requireHrUser(supabase);
-  if (denied) return denied;
+  const gate = await requireHrUser();
+  if ("denied" in gate) return gate.denied;
 
   const params = request.nextUrl.searchParams;
   const format = params.get("format") === "xlsx" ? "xlsx" : "csv";
   const mode = parseMode(params.get("mode"));
-  const { lookups } = await loadOrgLookups(supabase);
+  // Eine Transaktion für Nachschlagewerte und Daten: dort gilt der
+  // Sitzungskontext, und beide sehen denselben Lesestand.
+  const { rows, columns, filenameBase } = await withUser(gate.userId, async (tx) => {
+    const { lookups } = await loadOrgLookups(tx);
+    let rows: ReportRow[];
+    let columns: ExportColumn<ReportRow>[];
+    let filenameBase: string;
 
-  let rows: ReportRow[];
-  let columns: ExportColumn<ReportRow>[];
-  let filenameBase: string;
+    if (mode === "events") {
+      const group = parseEventGroupDimension(params.get("group"));
+      const split = parseEventSplitDimension(params.get("split"));
+      const eventType = parseEventType(params.get("eventType"));
+      const events = await loadEventHistory(tx, {
+        eventType: eventType ?? undefined,
+        division: params.get("division") ?? undefined,
+        location: params.get("location") ?? undefined,
+        from: parseEventDateParam(params.get("from")),
+        to: parseEventDateParam(params.get("to")),
+      });
+      rows = aggregateEvents(events, group, split, lookups);
+      columns = eventReportColumns(rows, group, split, sumValues(rows));
+      filenameBase = `ereignisse-${eventType ?? "alle"}-${group}`;
+    } else {
+      const measure = parseMeasure(params.get("measure"));
+      const group = parseGroupDimension(params.get("group"));
+      const split = parseSplitDimension(params.get("split"));
+      const asOf = parseIsoDateParam(params.get("asOf"));
+      const employees = await loadSnapshotEmployees(tx, {
+        division: params.get("division") ?? undefined,
+        location: params.get("location") ?? undefined,
+        status: params.get("status") ?? undefined,
+        employment: params.get("employment") ?? undefined,
+        asOf,
+      });
+      rows = aggregateReport(employees, measure, group, split, lookups, asOf);
+      columns = snapshotReportColumns(rows, measure, group, split, totalForRows(rows, measure));
+      filenameBase = `bericht-${measure}-${group}`;
+    }
 
-  if (mode === "events") {
-    const group = parseEventGroupDimension(params.get("group"));
-    const split = parseEventSplitDimension(params.get("split"));
-    const eventType = parseEventType(params.get("eventType"));
-    const events = await loadEventHistory(supabase, {
-      eventType: eventType ?? undefined,
-      division: params.get("division") ?? undefined,
-      location: params.get("location") ?? undefined,
-      from: parseEventDateParam(params.get("from")),
-      to: parseEventDateParam(params.get("to")),
-    });
-    rows = aggregateEvents(events, group, split, lookups);
-    columns = eventReportColumns(rows, group, split, sumValues(rows));
-    filenameBase = `ereignisse-${eventType ?? "alle"}-${group}`;
-  } else {
-    const measure = parseMeasure(params.get("measure"));
-    const group = parseGroupDimension(params.get("group"));
-    const split = parseSplitDimension(params.get("split"));
-    const asOf = parseIsoDateParam(params.get("asOf"));
-    const employees = await loadSnapshotEmployees(supabase, {
-      division: params.get("division") ?? undefined,
-      location: params.get("location") ?? undefined,
-      status: params.get("status") ?? undefined,
-      employment: params.get("employment") ?? undefined,
-      asOf,
-    });
-    rows = aggregateReport(employees, measure, group, split, lookups, asOf);
-    columns = snapshotReportColumns(rows, measure, group, split, totalForRows(rows, measure));
-    filenameBase = `bericht-${measure}-${group}`;
-  }
+    return { rows, columns, filenameBase };
+  });
 
   const filename = exportFilename(filenameBase, format);
+
   const body = format === "xlsx" ? await toXlsx(rows, columns, "Bericht") : toCsv(rows, columns);
   // TS 5.9's Uint8Array<ArrayBufferLike> vs DOM's BlobPart/ArrayBuffer<> generic
   // mismatch (microsoft/TypeScript#59417) — a real Uint8Array works fine here.