Stufe 0: Grundgerüst mit Rechenkern, Datenbank, Oberfläche und Docker-Betrieb

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
Claude
2026-10-17 16:37:54 +00:00
commit 92d26baa4b
45 changed files with 6143 additions and 0 deletions

99
test/api.test.ts Normal file
View File

@@ -0,0 +1,99 @@
// Prüft Server und Datenbank zusammen. Läuft nur mit TEST_DATABASE_URL (lokal und in der CI).
import { describe, it, expect, beforeAll, afterAll } from "vitest";
import type { FastifyInstance } from "fastify";
import { erstellePool, type Pool } from "../src/server/db.js";
import { migriere } from "../src/server/migrate.js";
import { baueApp } from "../src/server/app.js";
const url = process.env.TEST_DATABASE_URL;
describe.skipIf(!url)("API mit Datenbank", () => {
let pool: Pool;
let app: FastifyInstance;
beforeAll(async () => {
pool = erstellePool(url!);
await pool.query("drop schema public cascade; create schema public;");
await migriere(pool);
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht" });
});
afterAll(async () => {
await app?.close();
await pool?.end();
});
const anlegen = async (pfad: string, body: object, benutzer = "henning") => {
const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body, headers: { "x-benutzer": benutzer } });
expect(r.statusCode, r.body).toBe(201);
return r.json();
};
it("Migrationen laufen nur einmal", async () => {
expect(await migriere(pool)).toEqual([]);
});
it("Status", async () => {
const r = await app.inject("/api/status");
expect(r.json()).toMatchObject({ ok: true });
});
it("umbenannter Kontakt erscheint überall mit neuem Namen (Abnahme Stufe 0)", async () => {
const k = await anlegen("kontakte", { name: "Dachdeckerei Meier", rolle: "subunternehmer" });
const p = await anlegen("projekte", { nummer: "26-01", bezeichnung: "Dachstuhl Musterweg", bauherr_id: k.id, umsatz_netto: 4_500_000 });
const a = await anlegen("abschnitte", { projekt_id: p.id, name: "Montage" });
const v = await anlegen("vorgaenge", { abschnitt_id: a.id, name: "Eindecken", start: "2026-11-02", dauer: 3, kontakt_id: k.id });
const r = await app.inject({ method: "PATCH", url: `/api/kontakte/${k.id}`, payload: { name: "Meier Bedachungen GmbH" } });
expect(r.statusCode).toBe(200);
const sicht = await pool.query(
`select kp.name as bauherr, kv.name as ausfuehrend from projekt p
join kontakt kp on kp.id = p.bauherr_id join vorgang v on v.id = $2 join kontakt kv on kv.id = v.kontakt_id where p.id = $1`,
[p.id, v.id],
);
expect(sicht.rows[0]).toEqual({ bauherr: "Meier Bedachungen GmbH", ausfuehrend: "Meier Bedachungen GmbH" });
});
it("Beträge bleiben centgenau", async () => {
const p = await anlegen("projekte", { nummer: "26-02", bezeichnung: "Carport" });
const z = await anlegen("zahlungen", { projekt_id: p.id, bezeichnung: "Anzahlung", netto: 123_456_789_01, termin: "2026-11-02" });
expect(z.netto).toBe(123_456_789_01);
expect(z.termin).toBe("2026-11-02");
});
it("lehnt ungültige Eingaben ab", async () => {
const r1 = await app.inject({ method: "POST", url: "/api/kontakte", payload: { name: "" } });
expect(r1.statusCode).toBe(400);
const r2 = await app.inject({ method: "POST", url: "/api/zahlungen", payload: { projekt_id: crypto.randomUUID(), bezeichnung: "x", netto: 1, termin: "2026-01-01" } });
expect(r2.statusCode).toBe(409);
const r3 = await app.inject({ method: "POST", url: "/api/zahlungen", payload: { projekt_id: crypto.randomUUID(), bezeichnung: "x", netto: 1.5, termin: "2026-01-01" } });
expect(r3.statusCode).toBe(400);
});
it("Protokoll hält fest, wer was geändert hat", async () => {
const k = await anlegen("kontakte", { name: "Holzhandel Nord" }, "henning");
await app.inject({ method: "PATCH", url: `/api/kontakte/${k.id}`, payload: { telefon: "04541 123" }, headers: { "x-benutzer": "buero" } });
await app.inject({ method: "DELETE", url: `/api/kontakte/${k.id}`, headers: { "x-benutzer": "henning" } });
const r = (await app.inject(`/api/protokoll?datensatz=${k.id}`)).json();
expect(r.map((x: { aktion: string; benutzer: string }) => [x.aktion, x.benutzer])).toEqual([
["loeschen", "henning"], ["aendern", "buero"], ["anlegen", "henning"],
]);
});
it("Einstellungen mit Vorgaben und Liquidität aus der Datenbank", async () => {
const e = (await app.inject("/api/einstellungen")).json();
expect(e.arbeitstage).toEqual([1, 2, 3, 4]);
expect(e.ust.satz).toBe(19);
await app.inject({ method: "PUT", url: "/api/einstellungen", payload: { ...e, startsaldo: 500_000 } });
const p = await anlegen("projekte", { nummer: "26-03", bezeichnung: "Gaube" });
await anlegen("zahlungen", { projekt_id: p.id, bezeichnung: "Abschlag", netto: 1_000_000, termin: "2027-03-01" });
await anlegen("laufende-kosten", { bezeichnung: "Kfz-Versicherung", betrag: 60_000, rhythmus: "jaehrlich", start: "2027-03-20" });
const l = (await app.inject("/api/liquiditaet?ansicht=monat&start=2027-03-01&anzahl=1")).json();
expect(l[0]).toMatchObject({ einnahmen: 1_190_000, ausgaben: -60_000, kontostand: 500_000 + 1_190_000 - 60_000 });
});
it("Export enthält alle Tabellen", async () => {
const r = await app.inject("/api/export");
const j = r.json();
expect(Object.keys(j.daten)).toContain("vorgaenge");
expect(j.daten.kontakte.length).toBeGreaterThan(0);
});
});

73
test/geld.test.ts Normal file
View File

@@ -0,0 +1,73 @@
import { describe, it, expect } from "vitest";
import { prozentVon, brutto, parseEuro, formatEuro, zahlungsplanBetraege, STANDARD_ZAHLUNGSPLAN, summe } from "../src/domain/geld.js";
import { stundenZuArbeitstagen } from "../src/domain/arbeitszeit.js";
describe("Prozent und Umsatzsteuer", () => {
it("rundet kaufmännisch", () => {
expect(prozentVon(1, 50)).toBe(1); // 0,5 Cent -> 1
expect(prozentVon(-1, 50)).toBe(-1);
expect(prozentVon(105, 19)).toBe(20); // 19,95 -> 20
expect(prozentVon(1234567, 12.5)).toBe(154321); // 154320,875
});
it("kein Gleitkommafehler", () => {
// 0.1 + 0.2 in Euro wäre ungenau; in Cent exakt
expect(prozentVon(1000, 0.1)).toBe(1);
expect(brutto(1, 19)).toBe(1);
expect(brutto(1000000, 19)).toBe(1190000);
expect(brutto(1999, 19)).toBe(2379); // 3,7981 € USt -> 3,80
});
it("große Beträge exakt", () => {
expect(prozentVon(9_000_000_000_00, 19)).toBe(1_710_000_000_00);
});
});
describe("Beträge lesen und schreiben", () => {
it.each([
["1.234,56", 123456], ["1234,5", 123450], ["12", 1200], ["-12,01", -1201],
["1.000", 100000], ["12.50", 1250], ["0,07 €", 7],
])("%s", (text, cent) => expect(parseEuro(text)).toBe(cent));
it("lehnt Unsinn ab", () => {
expect(() => parseEuro("12,345")).toThrow();
expect(() => parseEuro("abc")).toThrow();
});
it("formatiert deutsch", () => {
expect(formatEuro(123456789)).toBe("1.234.567,89 €");
expect(formatEuro(-5)).toBe("-0,05 €");
expect(formatEuro(0, false)).toBe("0,00");
});
});
describe("Zahlungsplan P9", () => {
it("Standard 30/40/20/10", () => {
const b = zahlungsplanBetraege(10000000, STANDARD_ZAHLUNGSPLAN);
expect(b).toEqual([3000000, 4000000, 2000000, 1000000]);
});
it("Rest fällt auf die Schlussrechnung, Summe stimmt immer", () => {
const auftrag = 3333333; // 33.333,33 €
const b = zahlungsplanBetraege(auftrag, STANDARD_ZAHLUNGSPLAN);
expect(b).toEqual([1000000, 1333333, 666667, 333333]);
expect(summe(b)).toBe(auftrag);
});
it("fester Betrag gemischt mit Prozent", () => {
expect(zahlungsplanBetraege(5000000, [{ betrag: 500000 }, { prozent: 50 }, { prozent: 99 }])).toEqual([500000, 2500000, 2000000]);
});
});
describe("Stunden in Arbeitstage", () => {
it("rundet auf ganze Tage", () => {
expect(stundenZuArbeitstagen(0)).toBe(0);
expect(stundenZuArbeitstagen(1)).toBe(1);
expect(stundenZuArbeitstagen(8)).toBe(1);
expect(stundenZuArbeitstagen(8.5)).toBe(2);
expect(stundenZuArbeitstagen(24)).toBe(3);
});
it("Produktivität verlängert", () => {
expect(stundenZuArbeitstagen(24, { stundenProTag: 8, produktivitaet: 0.75, rundung: "auf" })).toBe(4);
expect(stundenZuArbeitstagen(0.3 * 8 * 10, { stundenProTag: 8, produktivitaet: 0.3, rundung: "auf" })).toBe(10);
});
it("halbe Tage und kaufmännisch", () => {
expect(stundenZuArbeitstagen(10, { stundenProTag: 8, produktivitaet: 1, rundung: "halbe" })).toBe(1.5);
expect(stundenZuArbeitstagen(11, { stundenProTag: 8, produktivitaet: 1, rundung: "kaufmaennisch" })).toBe(1);
expect(stundenZuArbeitstagen(12, { stundenProTag: 8, produktivitaet: 1, rundung: "kaufmaennisch" })).toBe(2);
});
});

86
test/kalender.test.ts Normal file
View File

@@ -0,0 +1,86 @@
import { describe, it, expect } from "vitest";
import { ostersonntag, feiertageSH, istArbeitstag, endeNachDauer, verschiebeArbeitstage, arbeitstageZwischen, naechsterArbeitstag } from "../src/domain/kalender.js";
import { plusMonate, wochentag, zuDate } from "../src/domain/datum.js";
describe("Ostersonntag", () => {
it.each([
[2024, "2024-03-31"], [2025, "2025-04-20"], [2026, "2026-04-05"], [2027, "2027-03-28"],
[2028, "2028-04-16"], [2030, "2030-04-21"], [2038, "2038-04-25"], [2000, "2000-04-23"],
])("%i", (jahr, erwartet) => expect(ostersonntag(jahr)).toBe(erwartet));
});
describe("Feiertage Schleswig-Holstein", () => {
it("2026 vollständig", () => {
expect(feiertageSH(2026).map((f) => f.datum)).toEqual([
"2026-01-01", "2026-04-03", "2026-04-06", "2026-05-01", "2026-05-14",
"2026-05-25", "2026-10-03", "2026-10-31", "2026-12-25", "2026-12-26",
]);
});
it("2027 vollständig", () => {
expect(feiertageSH(2027).map((f) => f.datum)).toEqual([
"2027-01-01", "2027-03-26", "2027-03-29", "2027-05-01", "2027-05-06",
"2027-05-17", "2027-10-03", "2027-10-31", "2027-12-25", "2027-12-26",
]);
});
it("keine Feiertage anderer Länder", () => {
const tage = feiertageSH(2026).map((f) => f.datum);
expect(tage).not.toContain("2026-01-06"); // Heilige Drei Könige
expect(tage).not.toContain("2026-06-04"); // Fronleichnam
expect(tage).not.toContain("2026-11-18"); // Buß- und Bettag (nur Sachsen)
});
it("Reformationstag erst ab 2018", () => {
expect(feiertageSH(2017).some((f) => f.name === "Reformationstag")).toBe(false);
expect(feiertageSH(2018).some((f) => f.name === "Reformationstag")).toBe(true);
});
});
describe("Arbeitstage Mo–Do", () => {
it("Freitag, Samstag, Sonntag sind frei", () => {
expect(istArbeitstag("2026-10-12")).toBe(true); // Mo
expect(istArbeitstag("2026-10-15")).toBe(true); // Do
expect(istArbeitstag("2026-10-16")).toBe(false); // Fr
expect(istArbeitstag("2026-10-17")).toBe(false); // Sa
expect(istArbeitstag("2026-10-18")).toBe(false); // So
});
it("Feiertag ist kein Arbeitstag", () => {
expect(istArbeitstag("2026-04-06")).toBe(false); // Ostermontag
expect(istArbeitstag("2026-05-14")).toBe(false); // Himmelfahrt (Do)
});
it("Start am Freitag beginnt am Montag", () => {
expect(naechsterArbeitstag("2026-10-16")).toBe("2026-10-19");
});
it("Dauer 4 Tage ab Montag endet Donnerstag", () => {
expect(endeNachDauer("2026-10-12", 4)).toBe("2026-10-15");
});
it("Dauer 5 Tage springt über Freitag bis Wochenende", () => {
expect(endeNachDauer("2026-10-12", 5)).toBe("2026-10-19");
});
it("Dauer über Ostern", () => {
// Do 02.04. ist Arbeitstag, Karfreitag und Ostermontag frei
expect(endeNachDauer("2026-04-01", 3)).toBe("2026-04-07");
});
it("Meilenstein mit Dauer 0", () => {
expect(endeNachDauer("2026-10-13", 0)).toBe("2026-10-13");
expect(endeNachDauer("2026-10-16", 0)).toBe("2026-10-19");
});
it("Verzögerung rückwärts", () => {
expect(verschiebeArbeitstage("2026-10-19", -1)).toBe("2026-10-15");
expect(verschiebeArbeitstage("2026-10-19", 0)).toBe("2026-10-19");
});
it("Arbeitstage im Oktober 2026", () => {
// 1.10.2026 ist Donnerstag: 5 Do + je 4 Mo, Di, Mi; 3.10. und 31.10. sind Samstage
expect(arbeitstageZwischen("2026-10-01", "2026-10-31")).toBe(17);
});
it("ganzes Jahr 2026", () => {
// 209 Mo–Do minus Neujahr (Do), Ostermontag, Himmelfahrt, Pfingstmontag
expect(arbeitstageZwischen("2026-01-01", "2026-12-31")).toBe(205);
});
it("rechnet unabhängig von der Zeitzone", () => {
expect(wochentag("2026-03-29")).toBe(7); // Zeitumstellung
expect(() => zuDate("2026-02-30")).toThrow();
});
it("Monatsende bleibt Monatsende", () => {
expect(plusMonate("2026-01-31", 1)).toBe("2026-02-28");
expect(plusMonate("2026-01-31", 2)).toBe("2026-03-31");
});
});

82
test/liquiditaet.test.ts Normal file
View File

@@ -0,0 +1,82 @@
import { describe, it, expect } from "vitest";
import { liquiditaet, periodenGrenzen, termineLaufend } from "../src/domain/liquiditaet.js";
import { faelligkeit, zeitraumVon } from "../src/domain/umsatzsteuer.js";
describe("Umsatzsteuer-Fälligkeit", () => {
it("10. des Folgemonats, Wochenende verschiebt auf Montag", () => {
expect(faelligkeit("2026-09", { dauerfristverlaengerung: false })).toBe("2026-10-12"); // 10.10. ist Sa
expect(faelligkeit("2026-10", { dauerfristverlaengerung: false })).toBe("2026-11-10"); // Di
});
it("Freitag bleibt Freitag (Freitagsregel gilt nicht)", () => {
expect(faelligkeit("2026-06", { dauerfristverlaengerung: false })).toBe("2026-07-10"); // Fr
});
it("Dauerfristverlängerung und Jahreswechsel", () => {
expect(faelligkeit("2026-12", { dauerfristverlaengerung: true })).toBe("2027-02-10");
expect(faelligkeit("2026-Q4", { dauerfristverlaengerung: false })).toBe("2027-01-11"); // 10.01.27 So
});
it("Zeitraum", () => {
expect(zeitraumVon("2026-05-31", "vierteljaehrlich")).toBe("2026-Q2");
});
});
describe("Perioden", () => {
it("Wochen beginnen montags", () => {
expect(periodenGrenzen({ ansicht: "woche", start: "2026-10-15", anzahl: 2 })).toEqual([
{ von: "2026-10-12", bis: "2026-10-18" },
{ von: "2026-10-19", bis: "2026-10-25" },
]);
});
it("Monate", () => {
expect(periodenGrenzen({ ansicht: "monat", start: "2026-12-15", anzahl: 2 })).toEqual([
{ von: "2026-12-01", bis: "2026-12-31" },
{ von: "2027-01-01", bis: "2027-01-31" },
]);
});
it("laufende Kosten vierteljährlich mit Ende", () => {
expect(termineLaufend({ bezeichnung: "Vers.", betrag: 1, rhythmus: "vierteljaehrlich", start: "2026-01-15", ende: "2026-09-30" }, "2026-01-01", "2026-12-31"))
.toEqual(["2026-01-15", "2026-04-15", "2026-07-15"]);
});
});
describe("Liquiditätsvorschau", () => {
const vorschau = { ansicht: "monat" as const, start: "2026-11-01", anzahl: 3, startsaldo: 1_000_000 };
it("rechnet Einnahmen, Kosten, laufende Kosten und USt centgenau", () => {
const p = liquiditaet(
{
einnahmen: [{ projekt: "26-01", bezeichnung: "Anzahlung", netto: 3_000_000, termin: "2026-11-02" }],
ausgaben: [{ projekt: "26-01", bezeichnung: "KVH", art: "material", netto: 1_000_000, termin: "2026-11-05" }],
laufend: [{ bezeichnung: "Miete", betrag: 80_000, rhythmus: "monatlich", start: "2026-01-03" }],
},
vorschau,
);
// November: Anzahlung 35.700 € (Ziel 14 Tage), Miete -800 €
expect(p[0]!.einnahmen).toBe(3_570_000);
expect(p[0]!.ausgaben).toBe(-80_000);
expect(p[0]!.kontostand).toBe(1_000_000 + 3_570_000 - 80_000);
// Dezember: Material 11.900 € (Ziel 30 Tage -> 05.12.), Miete, USt Nov (5.700 - 1.900 = 3.800) am 10.12.
expect(p[1]!.posten.map((x) => [x.datum, x.gruppe, x.betrag])).toEqual([
["2026-12-03", "Laufende Kosten", -80_000],
["2026-12-05", "Projektkosten", -1_190_000],
["2026-12-10", "Umsatzsteuer", -380_000],
]);
expect(p[2]!.kontostand).toBe(1_000_000 + 3_570_000 - 1_190_000 - 380_000 - 3 * 80_000);
});
it("Ist-Versteuerung verschiebt die USt in den Zahlungsmonat", () => {
const p = liquiditaet(
{ einnahmen: [{ bezeichnung: "Schluss", netto: 1_000_000, termin: "2026-11-25" }], ausgaben: [], laufend: [] },
{ ...vorschau, ust: { satz: 19, voranmeldung: "monatlich", dauerfristverlaengerung: false, versteuerung: "ist" } },
);
// Zahlung 09.12. -> USt Dezember fällig 11.01.2027 (10.01. ist Sonntag)
expect(p[2]!.posten).toEqual([{ datum: "2027-01-11", gruppe: "Umsatzsteuer", bezeichnung: "USt-Vorauszahlung 2026-12", betrag: -190_000 }]);
});
it("bezahlte Einnahme zählt am Zahltag", () => {
const p = liquiditaet(
{ einnahmen: [{ bezeichnung: "A", netto: 100, termin: "2026-10-01", bezahltAm: "2026-11-30" }], ausgaben: [], laufend: [] },
vorschau,
);
expect(p[0]!.einnahmen).toBe(119);
});
});