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/cron/apply-pending-changes/route.ts

@@ -1,5 +1,6 @@
 import { NextResponse, type NextRequest } from "next/server";
-import { createAdminClient } from "@/lib/supabase/admin";
+import { asSystem } from "@/lib/db";
+import { callFunction } from "@/lib/db/rpc";
 
 // Applies effective-dated changes (Versetzung/Beförderung/Karenz/Reorg/Daten
 // ändern with a future "Wirksam ab" date) once their date has arrived — see
@@ -13,13 +14,15 @@ export async function GET(request: NextRequest) {
     return NextResponse.json({ error: "Nicht autorisiert." }, { status: 401 });
   }
 
-  const supabase = createAdminClient();
-  const { data, error } = await supabase.rpc("apply_due_pending_changes");
-
-  if (error) {
-    console.error("apply_due_pending_changes failed:", error);
+  // Kein privilegierter Zugang mehr: derselbe Datenbankbenutzer ohne
+  // BYPASSRLS wie überall. apply_due_pending_changes ist SECURITY DEFINER
+  // und prüft selbst, was sie tut — der Dienstschlüssel, der RLS aushebelte,
+  // ist damit entfallen.
+  try {
+    const applied = await asSystem((tx) => callFunction(tx, "apply_due_pending_changes"));
+    return NextResponse.json({ applied });
+  } catch (err) {
+    console.error("apply_due_pending_changes failed:", err);
     return NextResponse.json({ error: "Interner Fehler." }, { status: 500 });
   }
-
-  return NextResponse.json({ applied: data });
 }

app/api/export/employees/route.ts

@@ -3,12 +3,11 @@ import { statusLabel } from "@/lib/absence";
 import { exportFilename, exportResponseHeaders, toCsv, toXlsx, type ExportColumn } from "@/lib/export";
 import { todayIso } from "@/lib/format";
 import { subtreeOf } from "@/lib/org";
-import { loadPlacements, loadReportingLines } from "@/lib/placement";
+import { loadPlacements, loadReportingLineMap } from "@/lib/placement";
 import { deriveStatusAsOf, parseIsoDateParam, parseStatuses, type OrgLookups } from "@/lib/reports";
 import { loadDependentsCounts, loadOrgLookups, type ReportFilters } from "@/lib/reports-data";
-import { requireHrUser } from "@/lib/supabase/auth";
-import { fetchAllRows } from "@/lib/supabase/query";
-import { createClient } from "@/lib/supabase/server";
+import { requireHrUser } from "@/lib/auth/require-hr";
+import { withUser } from "@/lib/db";
 import type { Database, EmploymentType, Weekday } from "@/lib/supabase/types";
 
 // Die Rohzeile plus die Einordnung, die nicht mehr auf ihr steht: sie kommt
@@ -26,9 +25,8 @@ type EmployeeRow = Database["public"]["Tables"]["employees"]["Row"] & {
 // filtering happens against the *derived* status as of that date rather
 // than the live `status` column — see deriveStatusAsOf.
 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";
@@ -44,22 +42,37 @@ export async function GET(request: NextRequest) {
 
   const stichtag = asOf ?? todayIso();
 
-  function employeeQuery() {
-    let query = supabase.from("employees").select("*").order("last_name").order("id");
-    if (filters.location) query = query.eq("location_id", filters.location);
-    if (filters.employment) query = query.eq("employment_type", filters.employment as EmploymentType);
-    if (!asOf) query = query.in("status", statuses);
-    return query;
-  }
+  const { employees, lookups, orgMaps, allEmployees, dependentsCounts, placements, lines } = await withUser(
+    gate.userId,
+    async (tx) => {
+      function employeeQuery() {
+        let q = tx.selectFrom("employees").selectAll().orderBy("last_name").orderBy("id");
+        if (filters.location) q = q.where("location_id", "=", filters.location);
+        if (filters.employment) q = q.where("employment_type", "=", filters.employment as EmploymentType);
+        if (!asOf) q = q.where("status", "in", statuses);
+        return q;
+      }
 
-  const [employees, { lookups, orgMaps }, allEmployees, dependentsCounts, placements, lines] = await Promise.all([
-    fetchAllRows(employeeQuery),
-    loadOrgLookups(supabase),
-    fetchAllRows(() => supabase.from("employees").select("id, first_name, last_name").order("id")),
-    loadDependentsCounts(supabase),
-    loadPlacements(supabase, { asOf: stichtag }),
-    loadReportingLines(supabase, stichtag),
-  ]);
+      const [employees, lookupResult, allEmployees, dependentsCounts, placements, lines] = await Promise.all([
+        employeeQuery().execute(),
+        loadOrgLookups(tx),
+        tx.selectFrom("employees").select(["id", "first_name", "last_name"]).orderBy("id").execute(),
+        loadDependentsCounts(tx),
+        loadPlacements(tx, { asOf: stichtag }),
+        loadReportingLineMap(tx, stichtag),
+      ]);
+
+      return {
+        employees,
+        lookups: lookupResult.lookups,
+        orgMaps: lookupResult.orgMaps,
+        allEmployees,
+        dependentsCounts,
+        placements,
+        lines,
+      };
+    }
+  );
 
   const managerName = new Map(allEmployees.map((e) => [e.id, `${e.first_name} ${e.last_name}`]));
   // Der Einheitenfilter meint den ganzen Teilbaum — sonst enthielte ein

app/api/export/events/route.ts

@@ -2,32 +2,34 @@ import { NextResponse, type NextRequest } from "next/server";
 import { exportFilename, exportResponseHeaders, toCsv, toXlsx, type ExportColumn } from "@/lib/export";
 import { EVENT_TYPE_LABELS, parseEventDateParam, parseEventType, type OrgLookups, type ReportEvent } from "@/lib/reports";
 import { loadEventHistory, loadOrgLookups } 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";
 
 // Full raw event-log dump — one row per employee_history entry in the
 // selected period (default: current year), every event type unless one is
 // picked, org columns resolved from each affected employee's current
 // placement (see loadEventHistory).
 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 eventType = parseEventType(params.get("eventType"));
 
-  const [{ lookups }, events] = await Promise.all([
-    loadOrgLookups(supabase),
-    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")),
-    }),
-  ]);
+  const { lookups, events } = await withUser(gate.userId, async (tx) => {
+    const [{ lookups }, events] = await Promise.all([
+      loadOrgLookups(tx),
+      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")),
+      }),
+    ]);
+    return { lookups, events };
+  });
 
   const columns = eventExportColumns(lookups);
   const filename = exportFilename(`ereignisse-${eventType ?? "alle"}`, format);

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.