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.

lib/orgchart-data.ts

@@ -1,9 +1,7 @@
-import type { SupabaseClient } from "@supabase/supabase-js";
 import type { OrgEmployee, OrgVacancy } from "@/components/orgchart/types";
+import type { Tx } from "./db";
 import { todayIso } from "./format";
 import { resolveReportingLines, type OmHolder, type OmUnit } from "./om-reporting";
-import { fetchAllRows } from "./supabase/query";
-import type { Database } from "./supabase/types";
 
 // Das Organigramm, wie es an einem Stichtag stand oder stehen wird.
 //
@@ -56,55 +54,76 @@ type AssignmentRow = { employee_id: string; position_id: string };
 
 type PendingRow = { employee_id: string; effective_date: string; payload: Record<string, unknown> };
 
-export async function loadOrgAsOf(supabase: SupabaseClient<Database>, asOf: string): Promise<OrgAsOfResult> {
+export async function loadOrgAsOf(tx: Tx, asOf: string): Promise<OrgAsOfResult> {
   const today = todayIso();
 
+  // Ohne die 1000-Zeilen-Grenze der API-Schicht fällt das seitenweise
+  // Nachladen weg: sechs Abfragen, jede vollständig.
   const [units, positions, assignments, employees, pending, earliest] = await Promise.all([
-    fetchAllRows(() => supabase.from("org_units").select("id, parent_id").order("id")),
-    fetchAllRows(() =>
-      supabase
-        .from("om_positions")
-        .select("id, position_number, org_unit_id, is_chief, jobs!inner(title)")
-        .lte("valid_from", asOf)
-        .or(`valid_to.is.null,valid_to.gt.${asOf}`)
-        .order("id")
-    ),
-    fetchAllRows(() =>
-      supabase
-        .from("position_assignments")
-        .select("employee_id, position_id")
-        .lte("valid_from", asOf)
-        .or(`valid_to.is.null,valid_to.gt.${asOf}`)
-        .order("employee_id")
-    ),
-    fetchAllRows(() =>
-      supabase
-        .from("employees")
-        .select("id, personnel_number, first_name, last_name, job_title, karenz_start_date, karenz_return_date, absence_type")
-        .order("id")
-    ),
+    tx.selectFrom("org_units").select(["id", "parent_id"]).orderBy("id").execute(),
+
+    tx
+      .selectFrom("om_positions as p")
+      .innerJoin("jobs as j", "j.id", "p.job_id")
+      .select(["p.id", "p.position_number", "p.org_unit_id", "p.is_chief", "j.title"])
+      .where("p.valid_from", "<=", asOf)
+      .where((eb) => eb.or([eb("p.valid_to", "is", null), eb("p.valid_to", ">", asOf)]))
+      .orderBy("p.id")
+      .execute(),
+
+    tx
+      .selectFrom("position_assignments")
+      .select(["employee_id", "position_id"])
+      .where("valid_from", "<=", asOf)
+      .where((eb) => eb.or([eb("valid_to", "is", null), eb("valid_to", ">", asOf)]))
+      .orderBy("employee_id")
+      .execute(),
+
+    tx
+      .selectFrom("employees")
+      .select([
+        "id",
+        "personnel_number",
+        "first_name",
+        "last_name",
+        "job_title",
+        "karenz_start_date",
+        "karenz_return_date",
+        "absence_type",
+      ])
+      .orderBy("id")
+      .execute(),
+
     asOf > today
-      ? fetchAllRows(() =>
-          supabase
-            .from("pending_org_changes")
-            .select("employee_id, effective_date, payload")
-            .eq("status", "pending")
-            .lte("effective_date", asOf)
-            .in("change_type", [...PLACEMENT_CHANGES])
-            .order("effective_date")
-        )
+      ? tx
+          .selectFrom("pending_org_changes")
+          .select(["employee_id", "effective_date", "payload"])
+          .where("status", "=", "pending")
+          .where("effective_date", "<=", asOf)
+          .where("change_type", "in", [...PLACEMENT_CHANGES])
+          .orderBy("effective_date")
+          .execute()
       : Promise.resolve([]),
-    supabase.from("position_assignments").select("valid_from").order("valid_from").limit(1).maybeSingle(),
+
+    tx.selectFrom("position_assignments").select("valid_from").orderBy("valid_from").limit(1).executeTakeFirst(),
   ]);
 
   return resolveOrgSnapshot({
     asOf,
     units: units.map((u) => ({ id: u.id, parentId: u.parent_id })),
-    positions: positions as unknown as PositionRow[],
+    // Der Join liefert den Jobtitel flach; die reine Funktion erwartet ihn
+    // verschachtelt, weil sie so auch aus einem Testbestand gefüttert wird.
+    positions: positions.map((p) => ({
+      id: p.id,
+      position_number: p.position_number,
+      org_unit_id: p.org_unit_id,
+      is_chief: p.is_chief,
+      jobs: { title: p.title },
+    })),
     assignments: assignments as AssignmentRow[],
     employees: employees as EmployeeRow[],
     pending: pending as PendingRow[],
-    historyStartsAt: earliest.data?.valid_from ?? null,
+    historyStartsAt: earliest?.valid_from ?? null,
   });
 }