feat: Projektgerüst, gehärteten Betriebsstand und Prozess aufsetzen

Legt die Grundlage, auf der alle weiteren Meilensteine nur noch Fachlichkeit
ergänzen: Next 16 mit App Router und TypeScript strict, Tailwind 4, Prisma 7,
Vitest 5, Playwright, ESLint, Prettier und die Hooks für Lint und Commits.

Zwei Dinge sind bewusst so gebaut und durch Tests festgehalten:

Die Datenbank ist im Betriebsstand von außen nicht erreichbar. Sie hat kein
ports:-Mapping und hängt allein im Netz "intern", das ohne Gateway läuft; nur
"web" kommt zusätzlich nach draußen. tests/betriebsstand.test.ts schlägt an,
falls ein Port-Mapping zurückkehrt. Geprüft, nicht behauptet: docker compose up
startet den Stack, 5432 ist vom Host aus zu, aus "web" offen.

pnpm pruefe:doku hält Dokumentation und Code zusammen — Version im Changelog,
Issue-Dateien gegen ihre Übersicht, keine Verweise auf fehlende Dateien, keine
fehlenden Bilder. Das Skript wurde gegen vier eingebaute Fehler gegengeprüft.

Drei Versions-Obergrenzen sind nötig und in CLAUDE.md begründet: eslint bleibt
auf 9.x, weil eslint-plugin-react keinen Nachfolger für eslint 10 hat und das
Regelwerk sonst beim Laden abbricht; typescript bleibt auf 6.0.x, weil
typescript-eslint TypeScript 7 noch nicht unterstützt; prisma ist exakt auf
7.10.0 gepinnt, weil sein latest-Tag auf einen 8.0-RC zeigt, der von
@prisma/client aber nicht.

Auth.js entfällt entgegen der ursprünglichen Vorgabe: v5 steht dauerhaft auf
Beta, das Projekt ist im Wartungsmodus und sein Prisma-Adapter deckt Prisma 7
nicht ab. Stattdessen openid-client und jose, wie in ProxLedger.

Dieser erste Commit geht direkt auf main, weil es noch keinen Branch gibt, von
dem abzuzweigen wäre. Ab #006 läuft jedes Issue über einen eigenen Branch.

Closes #5

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

tests/betriebsstand.test.ts

@@ -0,0 +1,58 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { parse } from "yaml";
+
+/**
+ * Die Datenbank im Betriebsstand ist absichtlich von aussen nicht erreichbar.
+ * Diese Tests halten das fest, damit ein ports:-Mapping nicht versehentlich
+ * zurueckkommt. Siehe docs/betrieb/inbetriebnahme.md.
+ */
+function compose(datei: string): Record<string, never> {
+  return parse(readFileSync(datei, "utf8")) as Record<string, never>;
+}
+
+describe("Betriebsstand: docker-compose.yml", () => {
+  const stand = compose("docker-compose.yml") as unknown as {
+    services: Record<string, { ports?: unknown[]; networks?: string[] }>;
+    networks: Record<string, { internal?: boolean } | null>;
+  };
+
+  it("veroeffentlicht keinen Port der Datenbank", () => {
+    expect(stand.services["postgres"]?.ports).toBeUndefined();
+  });
+
+  it("haengt die Datenbank nur in das interne Netz", () => {
+    expect(stand.services["postgres"]?.networks).toEqual(["intern"]);
+  });
+
+  it("hat das interne Netz ohne Gateway", () => {
+    expect(stand.networks["intern"]?.internal).toBe(true);
+  });
+
+  it("laesst nur den Webdienst in das externe Netz", () => {
+    const aussen = Object.entries(stand.services)
+      .filter(([, dienst]) => dienst.networks?.includes("extern"))
+      .map(([name]) => name);
+    expect(aussen).toEqual(["web"]);
+  });
+
+  it("bindet den Webdienst standardmaessig nur auf localhost", () => {
+    expect(stand.services["web"]?.ports).toEqual(["${BIND_ADDR:-127.0.0.1}:${APP_PORT:-3000}:3000"]);
+  });
+
+  it("bricht ohne Geheimnisse ab, statt mit Standardwerten zu starten", () => {
+    const roh = readFileSync("docker-compose.yml", "utf8");
+    expect(roh).toContain("${APP_SECRET:?");
+    expect(roh).toContain("${POSTGRES_PASSWORD:?");
+    expect(roh).toContain("${APP_URL:?");
+  });
+});
+
+describe("Betriebsstand: Entwicklungsdatenbank", () => {
+  it("laeuft auf 5433, damit ein lokales 5432 frei bleibt", () => {
+    const stand = compose("docker-compose.dev.yml") as unknown as {
+      services: Record<string, { ports?: string[] }>;
+    };
+    expect(stand.services["postgres"]?.ports).toEqual(["127.0.0.1:5433:5432"]);
+  });
+});

tests/global-setup.ts

@@ -0,0 +1,22 @@
+import "dotenv/config";
+
+/**
+ * Legt die Testdatenbank an und spielt die Migrationen ein.
+ * Ohne TEST_DATABASE_URL wird nur gewarnt; Datenbanktests ueberspringen sich dann
+ * selbst ueber `describe.runIf(datenbankVerfuegbar)`.
+ */
+export default async function aufbau(): Promise<void> {
+  const url = process.env["TEST_DATABASE_URL"];
+  if (!url) {
+    console.warn(
+      "\n  TEST_DATABASE_URL ist nicht gesetzt – Datenbanktests werden uebersprungen." +
+        "\n  Datenbank starten mit: pnpm db:up\n",
+    );
+    return;
+  }
+  const { execFileSync } = await import("node:child_process");
+  execFileSync("pnpm", ["exec", "prisma", "migrate", "deploy"], {
+    stdio: "inherit",
+    env: { ...process.env, DATABASE_URL: url },
+  });
+}

tests/helpers/db.ts

@@ -0,0 +1,24 @@
+import { PrismaPg } from "@prisma/adapter-pg";
+import { PrismaClient } from "@/generated/prisma/client";
+
+const url = process.env["TEST_DATABASE_URL"] ?? process.env["DATABASE_URL"];
+
+/** Ohne Testdatenbank ueberspringen sich die Datenbanktests statt fehlzuschlagen. */
+export const datenbankVerfuegbar = Boolean(url);
+
+export const testPrisma = new PrismaClient({
+  adapter: new PrismaPg({
+    connectionString: url ?? "postgresql://localhost:5432/laufzettel_test",
+  }),
+});
+
+/** Leert alle Tabellen; die Reihenfolge spielt dank CASCADE keine Rolle. */
+export async function datenbankLeeren(): Promise<void> {
+  const tabellen = await testPrisma.$queryRaw<{ tablename: string }[]>`
+    SELECT tablename FROM pg_tables
+    WHERE schemaname = 'public' AND tablename NOT LIKE '_prisma%'
+  `;
+  if (tabellen.length === 0) return;
+  const liste = tabellen.map((t) => `"public"."${t.tablename}"`).join(", ");
+  await testPrisma.$executeRawUnsafe(`TRUNCATE ${liste} RESTART IDENTITY CASCADE`);
+}

tests/navigation.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { navigationFuer } from "@/lib/navigation";
+
+describe("Seitenleiste", () => {
+  it("zeigt im Modus Intern die Kunden-Ebene nicht", () => {
+    const pfade = navigationFuer("INTERN").map((e) => e.pfad);
+    expect(pfade).not.toContain("/kunden");
+    expect(pfade).toContain("/mitarbeiter");
+  });
+
+  it("zeigt im Modus Dienstleistung Kunden statt Mitarbeiter & Geräte", () => {
+    const pfade = navigationFuer("DIENSTLEISTUNG").map((e) => e.pfad);
+    expect(pfade).toContain("/kunden");
+    expect(pfade).not.toContain("/mitarbeiter");
+  });
+
+  it("verlinkt keinen Eintrag, dessen Seite es noch nicht gibt", () => {
+    for (const eintrag of navigationFuer("INTERN")) {
+      if (!eintrag.verfuegbar) {
+        expect(eintrag.ausIssue, `${eintrag.pfad} braucht eine Issue-Nummer`).toBeGreaterThan(0);
+      }
+    }
+  });
+});

tests/setup-env.ts

@@ -0,0 +1,9 @@
+import "dotenv/config";
+
+// Tests laufen immer gegen die Testdatenbank, nie gegen die Entwicklungsdatenbank.
+if (process.env["TEST_DATABASE_URL"]) {
+  process.env["DATABASE_URL"] = process.env["TEST_DATABASE_URL"];
+}
+
+// Fuer Tests, die ein Geheimnis brauchen, ohne eine .env zu verlangen.
+process.env["APP_SECRET"] ??= "test-geheimnis-mit-mindestens-32-zeichen-laenge";

tests/version.test.ts

@@ -0,0 +1,8 @@
+import { describe, expect, it } from "vitest";
+import { versionText } from "@/lib/version";
+
+describe("Versionsanzeige", () => {
+  it("zeigt die Version mit fuehrendem v", () => {
+    expect(versionText()).toMatch(/^v\d+\.\d+\.\d+/);
+  });
+});