Remove Supabase

The database moved to a container of our own; the platform is gone.
This takes out what was left of it — and, where the leftovers were load
bearing, moves rather than deletes.

Moved, not deleted:

  supabase/migrations/  -> db/migrations/      the schema's source of truth
  supabase/build-org.ts -> scripts/build-org.ts
  lib/supabase/types.ts -> lib/types.ts        52 import sites repointed

The bookkeeping needed care. It lived in `supabase_migrations.schema_migrations`,
and simply renaming the schema would have left the runner facing an empty
table: it would have called all 67 migrations pending and replayed them
against a database that is long since current. So the runner now creates
`migrationen.schema_migrations` and, once, copies the old rows across —
guarded so a second run does nothing and a fresh database skips it entirely.
Only then does migration 20260907100000 drop the old schema.

Deleted: the CLI config, the seed, the historical schema/function dumps
(nothing read them), scripts/umzug-von-supabase.sh (the move is done), and
both Supabase packages plus the CLI. Nothing in the application imported
them — the build now succeeds with no environment variables at all, which
is the proof.

Integration tests: six of them signed in through Supabase Auth and asserted
against the anon key and the service role. That model is gone, so the tests
were not portable — they are deleted. session-context and
employee-status-filter already ran on pg and are untouched; om-reporting is
ported to a direct connection because it guards a real risk (the reporting
line rule exists twice, once in SQL and once in TypeScript).

CI: the integration job started a Supabase stack. It now runs a postgres
service, applies deploy/db-init and every migration to an empty database —
that was the valuable part, and it still holds — then checks that a second
run is a no-op, which is what proves the bookkeeping works.

Docs: security-review.md audited a service-role key, a cookie adapter and
auth.users, none of which exist. Restating findings about removed components
would suggest today's system had been reviewed; it has not. It now records
what was removed and says a fresh review is due. data-model.md was already
marked obsolete and described the pre-OM schema; azure-migration.md was a
plan for a route not taken. Both deleted.

Verified: npm ci, typecheck, lint, 445 tests, build — all clean without the
packages. Integration tests skip cleanly with no database. Migration SQL and
the runner are reviewed but NOT executed: no Docker here, and the old
instance no longer resolves.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

db/migrations/20260815100000_eintrittsdatum_und_rueckkehr_regel.sql

@@ -0,0 +1,413 @@
+-- Das Eintrittsdatum berichtigen — und eine Rückkehr nur aus einer Abwesenheit.
+--
+-- ═══ Eine Rückkehr setzt eine Abwesenheit voraus ═══
+--
+-- Diese Prüfung fehlte. In den Daten steht eine Person mit **zwei** Rückkehren
+-- zu einer Abwesenheit: die zweite wurde erfasst, als sie längst wieder aktiv
+-- war, und eine dritte war noch geplant. Der Status ergäbe sich danach aus
+-- einem Ereignis, das nie stattgefunden hat.
+--
+-- Zwei Bedingungen also: die Person muss abwesend sein, und es darf nicht
+-- schon eine Rückkehr geplant sein — eine zweite würde die erste am Stichtag
+-- stillschweigend überschreiben.
+--
+-- ═══ Das Eintrittsdatum ═══
+--
+-- Der Eintritt ist der Anfang der Zeitleiste und lässt sich nicht löschen.
+-- Sein Datum kann aber falsch erfasst sein, und dann hängt daran mehr als
+-- eine Zahl. Beim Ändern wird deshalb geprüft:
+--
+--   * Kein anderes Ereignis darf davor liegen — ein Trigger verbietet es
+--     ohnehin, hier steht der Grund lesbar statt als Auslösermeldung.
+--   * Austritt und Abwesenheitsbeginn dürfen nicht davor rutschen.
+--   * Die erste Planstellenbesetzung wandert mit. Bliebe sie stehen, gäbe es
+--     Tage mit Beschäftigung ohne Stelle oder umgekehrt.
+--
+-- Anders als die übrigen Einträge braucht der Eintritt dafür keine in
+-- `changes` hinterlegten Vorher-Werte: der alte Wert steht in employees.
+-- Damit funktioniert das auch für Zeilen, die lange vor dieser Erweiterung
+-- entstanden sind — und das ist der Fall, um den es geht.
+
+CREATE OR REPLACE FUNCTION public.record_karenz_return(payload jsonb)
+ RETURNS void
+ LANGUAGE plpgsql
+ SET search_path TO 'public', 'pg_temp'
+AS $function$
+declare
+  v_employee_id uuid := (payload->>'employee_id')::uuid;
+  v_return_date date := (payload->>'return_date')::date;
+  v_name text;
+  v_employment_type employment_type;
+  v_weekly_hours numeric;
+  v_karenz_start date;
+  v_absence_type text;
+  v_old employees%rowtype;
+  -- Wie bei der Abwesenheit: ohne Vorher-Werte liesse sich eine
+  -- irrtümlich erfasste Rückkehr nicht zurücknehmen.
+  v_changes jsonb := '[]'::jsonb;
+  -- Warum jemand mit weniger Stunden zurückkommt: Wiedereingliederungs-
+  -- oder Elternteilzeit. Nur bedeutsam, wenn überhaupt reduziert wird.
+  v_grund text := nullif(payload->>'reduction_reason', '');
+begin
+  perform require_hr_admin();
+  select * into v_old from employees where id = v_employee_id;
+  v_name := v_old.first_name || ' ' || v_old.last_name;
+  v_karenz_start := v_old.karenz_start_date;
+  v_absence_type := v_old.absence_type;
+
+  -- Ohne Abwesenheit keine Rückkehr. Die Prüfung fehlte, und in den Daten
+  -- steht eine Person mit zwei Rückkehren zu einer Abwesenheit: die zweite
+  -- wurde erfasst, als sie längst wieder aktiv war. Der Status wäre danach
+  -- aus einem Ereignis abgeleitet, das nie stattgefunden hat.
+  if v_old.status <> 'Karenz' and v_old.karenz_start_date is null then
+    raise exception 'Diese Person ist nicht abwesend — eine Rückkehr gibt es nur aus einer Abwesenheit.';
+  end if;
+
+  -- Und nur eine: eine zweite geplante Rückkehr würde die erste am
+  -- Stichtag stillschweigend überschreiben.
+  if exists (
+    select 1 from pending_org_changes p
+     where p.employee_id = v_employee_id and p.change_type = 'karenz_return' and p.status = 'pending'
+  ) then
+    raise exception 'Für diese Person ist bereits eine Rückkehr geplant. Sie muss zuerst zurückgenommen werden.';
+  end if;
+
+  if v_karenz_start is not null and v_return_date <= v_karenz_start then
+    raise exception 'Das Rückkehrdatum muss nach dem Beginn der Langzeitabwesenheit (%) liegen.', v_karenz_start;
+  end if;
+
+  if payload->>'employment_mode' = 'Vollzeit' then
+    v_employment_type := 'Vollzeit'; v_weekly_hours := 38.5;
+  elsif payload->>'employment_mode' = 'Teilzeit' then
+    v_employment_type := 'Teilzeit'; v_weekly_hours := (payload->>'weekly_hours')::numeric;
+  end if;
+
+  if v_return_date <= current_date then
+    -- Keine Manager-Nachführung mehr nötig: wer aus der Abwesenheit
+    -- zurückkehrt, ist wieder anwesend, und die abgeleitete Berichtslinie
+    -- fällt automatisch von der Vertretung auf ihn zurück.
+    update employees set
+      status = 'Aktiv',
+      karenz_return_date = null,
+      karenz_start_date = null,
+      absence_type = null,
+      employment_type = coalesce(v_employment_type, employment_type),
+      weekly_hours = coalesce(v_weekly_hours, weekly_hours),
+      -- Kehrt jemand reduziert zurück, ist der Grund dafür ein Zustand,
+      -- kein Einmalereignis: danach lässt sich auswerten, wer gerade in
+      -- Eltern- oder Wiedereingliederungsteilzeit ist.
+      teilzeit_art = case when payload->>'employment_mode' = 'Teilzeit' then v_grund else teilzeit_art end,
+      teilzeit_bis = case
+        when payload->>'employment_mode' = 'Teilzeit' and v_grund is not null
+          then nullif(payload->>'teilzeit_bis', '')::date
+        when payload->>'employment_mode' = 'Teilzeit' then null
+        else teilzeit_bis end
+    where id = v_employee_id;
+  else
+    update employees set karenz_return_date = v_return_date where id = v_employee_id;
+    insert into pending_org_changes (employee_id, change_type, effective_date, payload)
+      values (v_employee_id, 'karenz_return', v_return_date,
+        jsonb_build_object('employment_type', v_employment_type, 'weekly_hours', v_weekly_hours,
+          'teilzeit_art', v_grund, 'teilzeit_bis', nullif(payload->>'teilzeit_bis', '')));
+  end if;
+
+  if v_return_date <= current_date then
+    v_changes := app_aenderung(v_changes, 'Status', v_old.status::text, 'Aktiv');
+    v_changes := app_aenderung(v_changes, 'Art der Abwesenheit', v_old.absence_type, null);
+    v_changes := app_aenderung(v_changes, 'Abwesend ab', v_old.karenz_start_date::text, null);
+    v_changes := app_aenderung(v_changes, 'Geplante Rückkehr', v_old.karenz_return_date::text, null);
+    if v_employment_type is not null then
+      v_changes := app_aenderung(v_changes, 'Beschäftigungsausmaß', v_old.employment_type::text, v_employment_type::text);
+      v_changes := app_aenderung(v_changes, 'Wochenstunden', v_old.weekly_hours::text, v_weekly_hours::text);
+    end if;
+    if payload->>'employment_mode' = 'Teilzeit' then
+      v_changes := app_aenderung(v_changes, 'Teilzeitvariante', v_old.teilzeit_art, v_grund);
+      v_changes := app_aenderung(v_changes, 'Teilzeit bis', v_old.teilzeit_bis::text,
+        case when v_grund is not null then nullif(payload->>'teilzeit_bis', '') else null end);
+    end if;
+  end if;
+
+  insert into employee_history (employee_id, event_date, event_type, description, changes)
+    values (v_employee_id, v_return_date, 'Rückkehr',
+      'Rückkehr aus ' || coalesce(v_absence_type, 'Langzeitabwesenheit') || ' am ' || v_return_date
+      || case when payload->>'employment_mode' = 'Teilzeit'
+              then ', reduziert auf ' || (payload->>'weekly_hours') || ' h'
+                   || coalesce(' (' || v_grund || ')', '')
+              else '' end,
+      v_changes);
+
+  insert into audit_log (actor_user_id, actor_name, action, target_label, target_employee_id, details)
+    values (app_current_user_id(), current_actor_name(), 'Rückkehr', v_name, v_employee_id, 'Rückkehr am ' || v_return_date || coalesce(' — ' || v_grund, ''));
+end;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.update_history_entry(payload jsonb)
+ RETURNS void
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public', 'pg_temp'
+AS $function$
+declare
+  v_id uuid := (payload->>'history_id')::uuid;
+  v_eintrag employee_history%rowtype;
+  v_datum date;
+  v_name text;
+  v_karte constant jsonb := app_feld_karte();
+  v_alt jsonb;
+  v_feld text;
+  v_neuer_wert text;
+  v_neu jsonb := '[]'::jsonb;
+  v_korrektur jsonb := '[]'::jsonb;
+  v_setz text[] := '{}';
+  v_spalte text;
+  v_typ text;
+  v_gruppe text;
+  v_gueltig text;
+  v_plan pending_org_changes%rowtype;
+  v_neuer_payload jsonb;
+  v_war_zukunft boolean;
+  v_person employees%rowtype;
+  v_fruehestes date;
+begin
+  perform require_hr_admin();
+
+  select * into v_eintrag from employee_history where id = v_id;
+  if not found then
+    raise exception 'Historieneintrag nicht gefunden.';
+  end if;
+
+  -- ── Der Eintritt: nur das Datum, dafür ohne Vorher-Werte ────────
+  --
+  -- Er ist der Anfang der Zeitleiste und hat keine Felder, die sich
+  -- zurücknehmen liessen — wohl aber ein Datum, das falsch erfasst sein
+  -- kann. Anders als die übrigen Einträge braucht er dafür keine in
+  -- changes hinterlegten Werte: der alte Wert steht in employees.
+  -- Deshalb funktioniert das auch für Zeilen, die lange vor dieser
+  -- Erweiterung entstanden sind.
+  if v_eintrag.event_type = 'Eintritt' then
+    v_datum := coalesce(nullif(payload->>'event_date', '')::date, v_eintrag.event_date);
+    select * into v_person from employees where id = v_eintrag.employee_id;
+
+    if v_datum = v_person.entry_date then
+      raise exception 'Nichts geändert.';
+    end if;
+
+    -- Nichts darf vor dem Eintritt liegen. Ein Trigger verbietet es
+    -- ohnehin; hier steht der Grund lesbar statt als Auslösermeldung.
+    select min(h.event_date) into v_fruehestes
+      from employee_history h
+     where h.employee_id = v_eintrag.employee_id and h.id <> v_eintrag.id;
+    if v_fruehestes is not null and v_datum > v_fruehestes then
+      raise exception 'Am % steht bereits ein Ereignis. Der Eintritt kann nicht danach liegen.', v_fruehestes;
+    end if;
+
+    -- Wer schon angefangen hat, kann nicht künftig anfangen. Ohne diese
+    -- Prüfung liesse sich eine aktive Person durch ein Datum in der Zukunft
+    -- rückwirkend in einen geplanten Eintritt verwandeln — die Ableitung
+    -- sagt dann „Geplant", obwohl die Person seit Jahren da ist. Bei jemandem
+    -- ohne weitere Ereignisse greift sonst überhaupt nichts.
+    if v_person.status in ('Aktiv', 'Karenz') and v_datum > current_date then
+      raise exception 'Diese Person arbeitet bereits. Der Eintritt kann nicht in der Zukunft liegen.';
+    end if;
+
+    if v_person.exit_date is not null and v_datum > v_person.exit_date then
+      raise exception 'Der Austritt am % läge dann vor dem Eintritt.', v_person.exit_date;
+    end if;
+
+    if v_person.karenz_start_date is not null and v_datum > v_person.karenz_start_date then
+      raise exception 'Die Abwesenheit ab % läge dann vor dem Eintritt.', v_person.karenz_start_date;
+    end if;
+
+    -- Die erste Planstellenbesetzung beginnt mit dem Eintritt und wandert
+    -- mit. Bliebe sie stehen, gäbe es Tage mit Beschäftigung ohne Stelle
+    -- oder umgekehrt.
+    update position_assignments
+       set valid_from = v_datum
+     where employee_id = v_eintrag.employee_id
+       and valid_from = v_person.entry_date
+       and (valid_to is null or valid_to > v_datum);
+
+    update employees set entry_date = v_datum where id = v_eintrag.employee_id;
+
+    update employee_history
+       set event_date = v_datum,
+           description = regexp_replace(description, '^Eintritt', 'Eintritt')
+     where id = v_id;
+
+    insert into audit_log (actor_user_id, actor_name, action, target_label, target_employee_id, details, changes)
+      values (app_current_user_id(), current_actor_name(), 'Eintrittsdatum berichtigt',
+        v_person.first_name || ' ' || v_person.last_name, v_eintrag.employee_id,
+        'Eintritt vom ' || v_eintrag.event_date || ' auf ' || v_datum || ' berichtigt',
+        jsonb_build_array(jsonb_build_object('feld', 'Eintrittsdatum',
+          'vorher', v_eintrag.event_date::text, 'nachher', v_datum::text)));
+    return;
+  end if;
+
+  if v_eintrag.event_type not in ('Stammdatenänderung', 'Vertragsänderung', 'Karenz', 'Rückkehr') then
+    raise exception 'Dieser Vorgang lässt sich hier nicht berichtigen. Für % gibt es den passenden Weg.', v_eintrag.event_type;
+  end if;
+
+  if v_eintrag.event_type in ('Karenz', 'Rückkehr') and v_eintrag.event_date > current_date then
+    raise exception 'Diese Abwesenheit ist noch nicht wirksam. Sie muss über den Vorgang selbst berichtigt werden.';
+  end if;
+
+  if v_eintrag.changes is null or jsonb_array_length(v_eintrag.changes) = 0 then
+    raise exception 'Zu diesem Eintrag sind keine Feldwerte erfasst — es gibt nichts zu berichtigen.';
+  end if;
+
+  v_war_zukunft := v_eintrag.event_date > current_date;
+  v_datum := coalesce(nullif(payload->>'event_date', '')::date, v_eintrag.event_date);
+
+  -- Ein Eintrag bleibt auf seiner Seite der Gegenwart. Beides zu erlauben
+  -- hiesse, eine gelaufene Änderung in eine geplante zu verwandeln (oder
+  -- umgekehrt) — dann müssten Stammdaten und payload gegenläufig angepasst
+  -- werden, und dafür gibt es die fachlichen Vorgänge.
+  if v_war_zukunft and v_datum <= current_date then
+    raise exception 'Eine geplante Änderung lässt sich hier nicht vorziehen. Dafür ist „Daten ändern" der richtige Weg.';
+  end if;
+  if not v_war_zukunft and v_datum > current_date then
+    raise exception 'Eine bereits wirksame Änderung lässt sich nicht in die Zukunft verschieben.';
+  end if;
+
+  select first_name || ' ' || last_name into v_name from employees where id = v_eintrag.employee_id;
+
+  -- Neue Werteliste bauen: Vorher bleibt, Nachher darf ersetzt werden.
+  for v_alt in select * from jsonb_array_elements(v_eintrag.changes) loop
+    v_feld := v_alt->>'feld';
+    select w->>'nachher' into v_neuer_wert
+      from jsonb_array_elements(coalesce(payload->'werte', '[]'::jsonb)) w
+      where w->>'feld' = v_feld;
+
+    if v_neuer_wert is null then
+      v_neu := v_neu || v_alt;
+    else
+      v_neu := v_neu || jsonb_build_object('feld', v_feld, 'vorher', v_alt->>'vorher', 'nachher', nullif(v_neuer_wert, ''));
+      if coalesce(v_alt->>'nachher', '') is distinct from coalesce(nullif(v_neuer_wert, ''), '') then
+        v_korrektur := v_korrektur || jsonb_build_object('feld', v_feld, 'vorher', v_alt->>'nachher', 'nachher', nullif(v_neuer_wert, ''));
+      end if;
+    end if;
+  end loop;
+
+  if jsonb_array_length(v_korrektur) = 0 and v_datum = v_eintrag.event_date then
+    raise exception 'Nichts geändert.';
+  end if;
+
+  update employee_history
+    set changes = v_neu,
+        event_date = v_datum,
+        description = 'Geänderte Felder: ' || app_aenderungsfelder(v_neu) || ', wirksam ab ' || v_datum
+    where id = v_id;
+
+  -- ── Noch nicht wirksam: den geplanten Vorgang nachziehen ───────────
+  if v_war_zukunft then
+    if v_eintrag.pending_id is null then
+      raise exception 'Zu dieser geplanten Änderung ist kein Vorgang hinterlegt. Sie stammt aus der Zeit vor dieser Verknüpfung und lässt sich hier nicht berichtigen.';
+    end if;
+
+    select * into v_plan from pending_org_changes where id = v_eintrag.pending_id for update;
+    if not found or v_plan.status <> 'pending' then
+      raise exception 'Der geplante Vorgang läuft nicht mehr — er wurde bereits angewendet oder abgebrochen.';
+    end if;
+
+    v_neuer_payload := jsonb_set(v_plan.payload, '{effective_date}', to_jsonb(v_datum::text));
+    for v_alt in select * from jsonb_array_elements(v_neu) loop
+      v_feld := v_alt->>'feld';
+      if not v_karte ? v_feld then
+        continue;
+      end if;
+      v_spalte := v_karte->v_feld->>0;
+      v_typ := v_karte->v_feld->>1;
+      v_gruppe := v_karte->v_feld->>2;
+      if not v_neuer_payload ? v_gruppe then
+        v_neuer_payload := jsonb_set(v_neuer_payload, array[v_gruppe], '{}'::jsonb);
+      end if;
+      v_neuer_payload := jsonb_set(
+        v_neuer_payload,
+        array[v_gruppe, v_spalte],
+        case
+          when v_alt->>'nachher' is null then 'null'::jsonb
+          when v_typ = 'liste' then to_jsonb(string_to_array(v_alt->>'nachher', ', '))
+          when v_typ = 'boolean' then to_jsonb((v_alt->>'nachher')::boolean)
+          when v_typ = 'numeric' then to_jsonb((v_alt->>'nachher')::numeric)
+          else to_jsonb(v_alt->>'nachher')
+        end,
+        true);
+    end loop;
+
+    update pending_org_changes
+      set payload = v_neuer_payload, effective_date = v_datum
+      where id = v_plan.id;
+
+    insert into audit_log (actor_user_id, actor_name, action, target_label, target_employee_id, details, changes)
+      values (app_current_user_id(), current_actor_name(), 'Geplante Änderung berichtigt', v_name, v_eintrag.employee_id,
+        v_eintrag.event_type || ' zum ' || v_eintrag.event_date ||
+        case when v_datum <> v_eintrag.event_date then ' auf ' || v_datum || ' verschoben' else '' end ||
+        case when jsonb_array_length(v_korrektur) > 0 then '; berichtigt: ' || app_aenderungsfelder(v_korrektur) else '' end,
+        v_korrektur);
+    return;
+  end if;
+
+  -- ── Bereits wirksam: Stammdaten nachziehen ─────────────────────────
+  for v_feld in select distinct e->>'feld' from jsonb_array_elements(v_neu) e loop
+    if not v_karte ? v_feld then
+      continue;
+    end if;
+
+    select a->>'nachher' into v_gueltig
+      from employee_history h,
+           lateral jsonb_array_elements(coalesce(h.changes, '[]'::jsonb)) a
+      where h.employee_id = v_eintrag.employee_id
+        and a->>'feld' = v_feld
+        and h.event_date <= current_date
+      order by h.event_date desc, h.created_at desc
+      limit 1;
+
+    v_spalte := v_karte->v_feld->>0;
+    v_typ := v_karte->v_feld->>1;
+
+    if v_typ = 'liste' then
+      v_setz := v_setz || format('%I = coalesce(string_to_array(%L, '', ''), ''{}'')', v_spalte, nullif(v_gueltig, ''));
+    else
+      v_setz := v_setz || format('%I = %L::%s', v_spalte, nullif(v_gueltig, ''), v_typ);
+    end if;
+  end loop;
+
+  if array_length(v_setz, 1) > 0 then
+    begin
+      execute format('update employees set %s where id = %L', array_to_string(v_setz, ', '), v_eintrag.employee_id);
+    exception when check_violation then
+      raise exception 'Der berichtigte Wert passt nicht zum übrigen Stand (%). Zusammengehörende Felder — etwa Beschäftigungsausmaß und Wochenstunden — müssen gemeinsam stimmen.', sqlerrm;
+    end;
+  end if;
+
+  insert into audit_log (actor_user_id, actor_name, action, target_label, target_employee_id, details, changes)
+    values (app_current_user_id(), current_actor_name(), 'Historieneintrag berichtigt', v_name, v_eintrag.employee_id,
+      v_eintrag.event_type || ' vom ' || v_eintrag.event_date ||
+      case when v_datum <> v_eintrag.event_date then ' auf ' || v_datum || ' umdatiert' else '' end ||
+      case when jsonb_array_length(v_korrektur) > 0
+           then '; berichtigt: ' || app_aenderungsfelder(v_korrektur) else '' end,
+      v_korrektur);
+end;
+$function$;
+
+
+-- Selbstprüfung.
+do $$
+declare
+  v_ret text := pg_get_functiondef('public.record_karenz_return(jsonb)'::regprocedure);
+  v_upd text := pg_get_functiondef('public.update_history_entry(jsonb)'::regprocedure);
+begin
+  if v_ret not like '%nicht abwesend%' then
+    raise exception 'record_karenz_return prüft die Abwesenheit nicht';
+  end if;
+  if v_ret not like '%bereits eine Rückkehr geplant%' then
+    raise exception 'record_karenz_return lässt zwei geplante Rückkehren zu';
+  end if;
+  if v_upd not like '%set entry_date = v_datum%' then
+    raise exception 'update_history_entry ändert das Eintrittsdatum nicht';
+  end if;
+  if v_upd not like '%Der Eintritt kann nicht danach liegen%' then
+    raise exception 'Die Abhängigkeitsprüfung zum Eintritt fehlt';
+  end if;
+end
+$$;