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/positions.ts

@@ -1,8 +1,6 @@
-import type { SupabaseClient } from "@supabase/supabase-js";
+import type { Tx } from "./db";
 import { todayIso } from "./format";
 import { breadcrumbLabel, loadOrgMaps, type OrgMaps } from "./org";
-import { fetchAllRows } from "./supabase/query";
-import type { Database } from "./supabase/types";
 
 // Eine offene Stelle ist keine eigene Sache mehr. Sie ist eine Planstelle
 // ohne laufende Besetzung — Vakanz ist eine Eigenschaft der Planstelle, kein
@@ -23,16 +21,6 @@ export type OpenPositionResolved = {
   vacantSince: string;
 };
 
-type PositionRow = {
-  id: string;
-  position_number: string;
-  org_unit_id: string;
-  is_chief: boolean;
-  valid_from: string;
-  jobs: { title: string };
-  position_assignments: { employee_id: string; valid_from: string; valid_to: string | null }[];
-};
-
 /**
  * Wer eine unbesetzte Planstelle führen würde: die Leitung der eigenen
  * Einheit, für eine Leitungsplanstelle die der übergeordneten — dieselbe
@@ -43,70 +31,89 @@ function managerUnitFor(maps: OrgMaps, orgUnitId: string, isChief: boolean): str
   return maps.units.get(orgUnitId)?.parent_id ?? null;
 }
 
-export async function loadOpenPositions(supabase: SupabaseClient<Database>): Promise<OpenPositionResolved[]> {
+export async function loadOpenPositions(tx: Tx): Promise<OpenPositionResolved[]> {
   const asOf = todayIso();
 
-  const [orgMaps, positions] = await Promise.all([
-    loadOrgMaps(supabase),
-    fetchAllRows(() =>
-      supabase
-        .from("om_positions")
-        .select(
-          "id, position_number, org_unit_id, is_chief, valid_from, jobs!inner(title), position_assignments(employee_id, valid_from, valid_to)"
+  const [orgMaps, open] = await Promise.all([
+    loadOrgMaps(tx),
+    // Unbesetzt heisst: keine am Stichtag laufende Zuordnung. Als NOT EXISTS
+    // in der Datenbank statt als Filter über alle Planstellen im Speicher.
+    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", "p.valid_from", "j.title"])
+      .where("p.valid_from", "<=", asOf)
+      .where((eb) => eb.or([eb("p.valid_to", "is", null), eb("p.valid_to", ">", asOf)]))
+      .where((eb) =>
+        eb.not(
+          eb.exists(
+            eb
+              .selectFrom("position_assignments as a")
+              .select("a.id")
+              .whereRef("a.position_id", "=", "p.id")
+              .where("a.valid_from", "<=", asOf)
+              .where((e2) => e2.or([e2("a.valid_to", "is", null), e2("a.valid_to", ">", asOf)]))
+          )
         )
-        .lte("valid_from", asOf)
-        .or(`valid_to.is.null,valid_to.gt.${asOf}`)
-        .order("position_number")
-    ),
+      )
+      .orderBy("p.position_number")
+      .execute(),
   ]);
 
-  const open = (positions as unknown as PositionRow[]).filter(
-    (p) => !p.position_assignments.some((a) => a.valid_from <= asOf && (a.valid_to === null || a.valid_to > asOf))
-  );
   if (open.length === 0) return [];
 
-  // Die Leitung der zuständigen Einheit — genau die Planstellen, die als
-  // Leitung markiert und laufend besetzt sind.
-  const chiefUnitIds = Array.from(
-    new Set(open.map((p) => managerUnitFor(orgMaps, p.org_unit_id, p.is_chief)).filter((id): id is string => Boolean(id)))
-  );
-  const chiefs = chiefUnitIds.length
-    ? ((await fetchAllRows(() =>
-        supabase
-          .from("om_positions")
-          .select("org_unit_id, position_assignments!inner(employees!inner(first_name, last_name), valid_to)")
-          .eq("is_chief", true)
-          .in("org_unit_id", chiefUnitIds)
-          .is("position_assignments.valid_to", null)
-      )) as unknown as {
-        org_unit_id: string;
-        position_assignments: { employees: { first_name: string; last_name: string } }[];
-      }[])
-    : [];
+  const positionIds = open.map((p) => p.id);
 
-  const chiefNameByUnit = new Map(
-    chiefs.flatMap((c) => {
-      const holder = c.position_assignments[0]?.employees;
-      return holder ? [[c.org_unit_id, `${holder.first_name} ${holder.last_name}`] as const] : [];
-    })
-  );
+  // Zwei Nachschläge: seit wann die Stelle leer steht, und wer sie führen
+  // würde.
+  const [ended, chiefs] = await Promise.all([
+    tx
+      .selectFrom("position_assignments")
+      .select(["position_id", "valid_to"])
+      .where("position_id", "in", positionIds)
+      .where("valid_to", "is not", null)
+      .execute(),
+    (async () => {
+      const chiefUnitIds = Array.from(
+        new Set(
+          open
+            .map((p) => managerUnitFor(orgMaps, p.org_unit_id, p.is_chief))
+            .filter((id): id is string => Boolean(id))
+        )
+      );
+      if (chiefUnitIds.length === 0) return [];
+      return tx
+        .selectFrom("om_positions as p")
+        .innerJoin("position_assignments as a", "a.position_id", "p.id")
+        .innerJoin("employees as e", "e.id", "a.employee_id")
+        .select(["p.org_unit_id", "e.first_name", "e.last_name"])
+        .where("p.is_chief", "=", true)
+        .where("p.valid_to", "is", null)
+        .where("a.valid_to", "is", null)
+        .where("p.org_unit_id", "in", chiefUnitIds)
+        .execute();
+    })(),
+  ]);
+
+  const lastEndByPosition = new Map<string, string>();
+  for (const e of ended) {
+    const prev = lastEndByPosition.get(e.position_id);
+    if (e.valid_to && (!prev || e.valid_to > prev)) lastEndByPosition.set(e.position_id, e.valid_to);
+  }
+  const chiefNameByUnit = new Map(chiefs.map((c) => [c.org_unit_id, `${c.first_name} ${c.last_name}`]));
 
   return open.map((p) => {
-    const ended = p.position_assignments
-      .map((a) => a.valid_to)
-      .filter((d): d is string => d !== null)
-      .sort();
     const managerUnit = managerUnitFor(orgMaps, p.org_unit_id, p.is_chief);
     return {
       id: p.id,
       position_number: p.position_number,
-      title: p.jobs.title,
+      title: p.title,
       org_unit_id: p.org_unit_id,
       is_chief: p.is_chief,
       valid_from: p.valid_from,
       managerName: managerUnit ? (chiefNameByUnit.get(managerUnit) ?? null) : null,
       orgLabel: breadcrumbLabel(orgMaps, p.org_unit_id),
-      vacantSince: ended.at(-1) ?? p.valid_from,
+      vacantSince: lastEndByPosition.get(p.id) ?? p.valid_from,
     };
   });
 }