dogfather-universe/server/pruef-personen-loeschen.mjs

/* ===================================================================
   Pruefung: Personen loeschen.

   Die einzige unumkehrbare Handlung im Workspace. Geprueft wird
   entsprechend vor allem, was NICHT gehen darf -- und dass die Sicherung
   davor wirklich geschrieben wird. Ohne sie waere "geloescht" endgueltig.
   =================================================================== */
import { mkdtempSync, rmSync, readdirSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { eigenerPort } from "./helfer-port.mjs";

const ordner = mkdtempSync(join(tmpdir(), "ws-loeschen-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
   Ohne diese Zeile startet der eigene Server bei belegtem Port
   STILL nicht -- und alles Folgende misst gegen einen fremden
   Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
   als kaputt. */
const PORT = await eigenerPort(import.meta, "pruef-personen-loeschen");
process.env.PORT = `${PORT}`;
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";

const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
await import("./index.js");
await new Promise((r) => setTimeout(r, 700));
const BASIS = `http://127.0.0.1:${PORT}`;
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 200_000).unref?.();

/* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des
   Benutzers; toISOString() liefert dagegen UTC und damit zwischen
   Mitternacht und 2 Uhr den VORTAG. In diesem Fenster schlug diese
   Pruefung fehl, ohne dass etwas kaputt war. */
const tagText = (d = new Date()) =>
  `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`
  + `-${String(d.getDate()).padStart(2, "0")}`;

let fehler = 0;
const ok = (b, t) => { console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
const heute = tagText();
function anlegen(name, rolle, code) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(code, salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idDogi   = anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idDogi2  = anlegen("VanVan", "admin", "CODE-VANV-0001");
const idManager = anlegen("Ein Manager", "manager", "CODE-MANA-0001");
const idScout  = anlegen("Patrick", "scout", "CODE-SCOU-0001");
const idAnna   = anlegen("Anna", "creator", "CODE-ANNA-0001");
const idLeer   = anlegen("Niemand", "creator", "CODE-LEER-0001");

/* Anna haengt voller Daten -- daran muss sich zeigen, was mitgeht und
   was bleibt. */
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idAnna, idScout, jetzt);
d.prepare("INSERT INTO profile (person_id, nische) VALUES (?, 'Basteln')").run(idAnna);
for (const f of ["a", "b", "c"]) {
  d.prepare("INSERT INTO startcheck (creator_id, feld, punkt, bewertung, geaendert) VALUES (?,?,'p','ok',?)")
    .run(idAnna, f, jetzt);
}
d.prepare("INSERT INTO content_saeulen (creator_id, name, slot, erstellt) VALUES (?, 'Tutorials', 1, ?)")
  .run(idAnna, jetzt);
for (let i = 0; i < 4; i++) {
  d.prepare("INSERT INTO aufgaben (titel, status, creator_id, erstellt, erstellt_von) VALUES ('Test','offen',?,?,?)")
    .run(idAnna, jetzt, idDogi);
}
d.prepare("INSERT INTO eintraege (bereich, art, titel, datum, status, creator_id, erstellt, erstellt_von) VALUES ('live','auswertung','Test',?,'offen',?,?,?)")
  .run(heute, idAnna, jetzt, idDogi);
d.prepare("INSERT INTO termine (titel, beginn, creator_id, erledigt, erstellt, erstellt_von) VALUES ('Test',?,?,0,?,?)")
  .run(heute + "T10:00", idAnna, jetzt, idDogi);
d.close();

const anmelden = async (rolle, code) => {
  const a = await fetch(BASIS + "/workspace/api/anmelden", {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ rolle, code }), redirect: "manual" });
  return (a.headers.getSetCookie?.() || []).map((c) => c.split(";")[0]).join("; ");
};
const ruf = (pfad, keks, opt = {}) => fetch(BASIS + pfad, {
  ...opt, headers: { cookie: keks, "Content-Type": "application/json", ...(opt.headers || {}) } });
const jsn = async (a) => { try { return await a.json(); } catch { return {}; } };
const zaehle = (sql, ...w) => {
  const v = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
  try { return v.prepare(sql).get(...w).n; } finally { v.close(); }
};
const sicherungen = () => {
  try { return readdirSync(join(ordner, "sicherungen")).filter((n) => n.endsWith(".db")).length; }
  catch { return 0; }
};

const kDogi = await anmelden("admin", "CODE-DOGI-0001");
const kManager = await anmelden("manager", "CODE-MANA-0001");
const kScout = await anmelden("scout", "CODE-SCOU-0001");

console.log("\n1) Die Vorschau sagt, was daran hängt");
{
  const v = await jsn(await ruf(`/workspace/api/verwaltung/personen/${idAnna}/loeschbar`, kDogi));
  console.log("   mit:   ", JSON.stringify(v.mit));
  console.log("   bleibt:", JSON.stringify(v.bleibt));
  ok(v.mit["Profil"] === 1, `Profil geht mit (${v.mit?.["Profil"]})`);
  ok(v.mit["Start-Check"] === 3, `Start-Check geht mit (${v.mit?.["Start-Check"]})`);
  ok(v.mit["Content-Säulen"] === 1, `Säulen gehen mit (${v.mit?.["Content-Säulen"]})`);
  ok(v.bleibt["Aufgaben"] === 4, `Aufgaben bleiben (${v.bleibt?.["Aufgaben"]})`);
  ok(v.bleibt["Termine"] === 1, `Termine bleiben (${v.bleibt?.["Termine"]})`);
  ok(v.hindernis === null, `kein Hindernis (${v.hindernis})`);
}

console.log("\n2) Beim Scout wird gewarnt, wer ohne Betreuung dasteht");
{
  const v = await jsn(await ruf(`/workspace/api/verwaltung/personen/${idScout}/loeschbar`, kDogi));
  ok(v.verliertBetreuung.length === 1 && v.verliertBetreuung[0] === "Anna",
     `Anna verliert ihre Betreuung (${v.verliertBetreuung.join(", ")})`);
}

console.log("\n3) Was NICHT gehen darf");
{
  const nurName = (id) => ({ method: "DELETE", body: JSON.stringify({ name: "egal" }) });

  /* Ein Manager darf gar nichts loeschen -- und soll nicht einmal
     erfahren, dass es den Weg gibt. */
  const m1 = await ruf(`/workspace/api/verwaltung/personen/${idLeer}`, kManager, nurName());
  ok(m1.status === 404, `Manager bekommt 404 beim Löschen (${m1.status})`);
  const m2 = await ruf(`/workspace/api/verwaltung/personen/${idLeer}/loeschbar`, kManager);
  ok(m2.status === 404, `und sieht nicht einmal die Vorschau (${m2.status})`);

  /* Ein Scout kommt gar nicht erst in die Verwaltung. */
  const s1 = await ruf(`/workspace/api/verwaltung/personen/${idLeer}`, kScout, nurName());
  ok(s1.status === 404, `Scout ebenfalls 404 (${s1.status})`);

  /* Sich selbst nicht. */
  const selbst = await ruf(`/workspace/api/verwaltung/personen/${idDogi}`, kDogi, {
    method: "DELETE", body: JSON.stringify({ name: "Filipe" }) });
  ok(selbst.status === 400, `sich selbst nicht (${selbst.status})`);
  console.log("   ->", (await jsn(selbst)).fehler);

  /* Falscher Name -- der haeufigste Fall beim Verklicken. */
  const falsch = await ruf(`/workspace/api/verwaltung/personen/${idLeer}`, kDogi, {
    method: "DELETE", body: JSON.stringify({ name: "Niemand " + "x" }) });
  ok(falsch.status === 400, `falscher Name wird abgelehnt (${falsch.status})`);
  ok(zaehle("SELECT COUNT(*) AS n FROM personen WHERE id = ?", idLeer) === 1,
     "und die Person ist noch da");

  /* Ohne Namen ueberhaupt. */
  const ohne = await ruf(`/workspace/api/verwaltung/personen/${idLeer}`, kDogi, {
    method: "DELETE", body: JSON.stringify({}) });
  ok(ohne.status === 400, `ohne Namen abgelehnt (${ohne.status})`);
}

console.log("\n4) Löschen schreibt vorher eine Sicherung");
{
  const vorher = sicherungen();
  const a = await ruf(`/workspace/api/verwaltung/personen/${idLeer}`, kDogi, {
    method: "DELETE", body: JSON.stringify({ name: "Niemand" }) });
  const j = await jsn(a);
  ok(a.ok, `gelöscht (${a.status})`);
  ok(!!j.sicherung, `die Sicherung wird genannt (${j.sicherung})`);
  ok(sicherungen() > vorher || sicherungen() >= 1, `es liegt eine Sicherung (${sicherungen()})`);
  ok(zaehle("SELECT COUNT(*) AS n FROM personen WHERE id = ?", idLeer) === 0, "die Person ist weg");

  /* Und die Sicherung enthaelt sie noch -- sonst waere sie wertlos. */
  const s = new DatabaseSync(join(ordner, "sicherungen", j.sicherung), { readOnly: true });
  const drin = s.prepare("SELECT COUNT(*) AS n FROM personen WHERE name = 'Niemand'").get().n;
  s.close();
  ok(drin === 1, `und in der Sicherung steht sie noch drin (${drin})`);
}

console.log("\n5) Anhängendes verhält sich wie angekündigt");
{
  const a = await ruf(`/workspace/api/verwaltung/personen/${idAnna}`, kDogi, {
    method: "DELETE", body: JSON.stringify({ name: "Anna" }) });
  ok(a.ok, `Anna gelöscht (${a.status})`);

  ok(zaehle("SELECT COUNT(*) AS n FROM profile WHERE person_id = ?", idAnna) === 0, "Profil ist mit weg");
  ok(zaehle("SELECT COUNT(*) AS n FROM startcheck WHERE creator_id = ?", idAnna) === 0, "Start-Check ist mit weg");
  ok(zaehle("SELECT COUNT(*) AS n FROM content_saeulen WHERE creator_id = ?", idAnna) === 0, "Säulen sind mit weg");
  ok(zaehle("SELECT COUNT(*) AS n FROM betreuung WHERE creator_id = ?", idAnna) === 0, "Zuständigkeit ist mit weg");

  /* Und das Gegenstueck: Die Arbeit bleibt. Eine Aufgabe verschwinden
     zu lassen, weil jemand geht, waere Geschichtsfaelschung. */
  ok(zaehle("SELECT COUNT(*) AS n FROM aufgaben") === 4, "die 4 Aufgaben sind noch da");
  ok(zaehle("SELECT COUNT(*) AS n FROM aufgaben WHERE creator_id IS NULL") === 4,
     "sie haben nur ihre Zuordnung verloren");
  ok(zaehle("SELECT COUNT(*) AS n FROM eintraege") === 1, "der Bereichseintrag ist noch da");
  ok(zaehle("SELECT COUNT(*) AS n FROM termine") === 1, "der Termin ist noch da");
}

console.log("\n6) Der letzte DogFather lässt sich nicht löschen");
{
  /* VanVan zuerst weg -- danach ist Filipe der letzte, und ein zweiter
     DogFather muss ihn dann ablehnen. */
  const weg = await ruf(`/workspace/api/verwaltung/personen/${idDogi2}`, kDogi, {
    method: "DELETE", body: JSON.stringify({ name: "VanVan" }) });
  ok(weg.ok, `der zweite DogFather geht (${weg.status})`);

  const v = await jsn(await ruf(`/workspace/api/verwaltung/personen/${idDogi}/loeschbar`, kDogi));
  ok(/selbst/.test(v.hindernis || ""), `die Vorschau nennt das Hindernis ("${v.hindernis}")`);
  ok(v.person.rolle === "admin", "und es ist der letzte DogFather-Zugang");
  ok(zaehle("SELECT COUNT(*) AS n FROM personen WHERE rolle = 'admin'") === 1,
     "es bleibt genau ein DogFather");
}

console.log("\n6b) Jede Löschung bekommt ihre EIGENE Sicherung");
{
  /* Der Mangel, den die erste Fassung dieser Prüfung sichtbar gemacht
     hat: Alle drei Löschungen schrieben in dieselbe Tagesdatei. Nach der
     dritten kannte die Sicherung die ERSTE gelöschte Person nicht mehr --
     die Sicherung hätte genau in dem Fall versagt, für den sie da ist. */
  const dateien = readdirSync(join(ordner, "sicherungen")).filter((n) => n.startsWith("vorher-"));
  console.log("   ", dateien.join(" · "));
  ok(dateien.length === 3, `drei eigene Sicherungen, eine je Löschung (${dateien.length})`);
  ok(new Set(dateien).size === dateien.length, "alle mit verschiedenen Namen");

  /* Die eigentlich zugesicherte Eigenschaft: JEDE gelöschte Person muss
     sich aus IRGENDEINER dieser Sicherungen zurückholen lassen. Genau
     das war vorher nicht der Fall.

     (Die erste Fassung dieser Prüfung griff die alphabetisch erste Datei
     und nannte sie "die älteste" -- "vorher-…-2.db" sortiert aber VOR
     "vorher-….db", weil "-" kleiner ist als ".". Sie prüfte damit die
     falsche Datei. Deshalb jetzt die Eigenschaft selbst statt eines
     Stellvertreters.) */
  for (const wer of ["Niemand", "Anna", "VanVan"]) {
    const gefunden = dateien.some((datei) => {
      const s = new DatabaseSync(join(ordner, "sicherungen", datei), { readOnly: true });
      try { return s.prepare("SELECT COUNT(*) AS n FROM personen WHERE name = ?").get(wer).n > 0; }
      finally { s.close(); }
    });
    ok(gefunden, `„${wer}" lässt sich aus einer der Sicherungen zurückholen`);
  }

  /* Und: Eine Sicherung vor dem Löschen darf NICHT als der planmäßige
     Nachtlauf gelten -- sonst liefe in der Nacht keiner mehr. */
  const v = new DatabaseSync(process.env.WORKSPACE_DB, { readOnly: true });
  const vermerk = v.prepare(
    "SELECT wert FROM einstellungen WHERE schluessel = 'sicherung_letzte'").get()?.wert;
  v.close();
  ok(!vermerk || !/vorher-/.test(vermerk),
     `der planmäßige Vermerk bleibt unberührt (${vermerk ? JSON.parse(vermerk).datei : "keiner"})`);
}

console.log("\n7) Das Protokoll hält es fest");
{
  const { eintraege } = await jsn(await ruf("/workspace/api/verwaltung/protokoll?anzahl=40", kDogi));
  const geloescht = (eintraege || []).filter((e) => e.aktion === "person_geloescht");
  ok(geloescht.length === 3, `drei Löschungen im Protokoll (${geloescht.length})`);
  ok(/Sicherung:/.test(geloescht[0]?.detail || ""),
     `mit der Sicherung im Eintrag ("${geloescht[0]?.detail}")`);
}

console.log(`\n${fehler === 0 ? "Alles in Ordnung." : fehler + " Prüfung(en) fehlgeschlagen."}`);
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
process.exit(fehler === 0 ? 0 : 1);