AUD-03: audit-log-export-filter-api

internal/audit/export.go: StreamCSV/StreamJSON filtern nach Tenant, Akteur,
Aktion und Zeitraum (Akzeptanzkriterium 1) und schreiben Zeile fuer Zeile
ueber rows.Next() DIREKT auf den uebergebenen io.Writer — zu keinem
Zeitpunkt wird das komplette Ergebnis im Speicher aufgebaut (Akzeptanz-
kriterium 3). JSON-Export als JSON Lines statt einem grossen Array, um
Streaming ohne Sonderbehandlung von Klammern/Kommas zu ermoeglichen.

ExportHandler (Akzeptanzkriterium 2) schreibt direkt auf http.ResponseWriter
— derselbe Streaming-Pfad wie in Tests, kein Zwischenpuffer nur fuer HTTP.
Authorize ist eine schmale Schnittstelle (Vorbild: AUD-05 RetentionRegistrar-
Muster), da die eigentliche Rollenpruefung RBAC-02 (Policy-Enforcement) ist
und nicht Teil dieser Kachel — der Handler kennt nur "darf dieser Aufrufer
exportieren", nicht wie das entschieden wird.

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Export mit hoher Eintragszahl ohne uebermaessigen Speicherverbrauch —
   TestExport_StreamsLargeResultWithoutExcessiveMemory: 20.000 Eintraege,
   Heap-Wachstum waehrend Export nur ~1.8KB (Schwelle 3MB). PASS.
2. Filterkombinationen automatisiert gegen erwartete Ergebnismengen —
   TestExport_FilterCombinations (Tenant/Actor/Action einzeln und kombiniert)
   und TestExport_TimeRangeFilter (innerhalb/ausserhalb Zeitraum). PASS.
3. Zugriff ohne passende Berechtigung abgewiesen —
   TestExportHandler_RejectsWithoutAuthorization: fehlender/falscher caller
   -> 403, berechtigter caller -> 200. PASS.

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

cmd/core/main.go

@@ -8,7 +8,6 @@ import (
 	"gitea.perlbach24.de/scripte/nexarch/internal/config"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
 	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 
 func main() {
@@ -35,20 +34,12 @@ func main() {
 	provisioner := tenant.NewProvisioner(adminPool, registry, cfg.TenantDSNTemplate)
 	tenantHandler := tenant.NewHandler(provisioner)
 
-	// Superadmin-Konten leben mandantenuebergreifend in der Registry-DB.
-	// Tenant-User-CRUD (user.TenantUserStore) braucht Connection-Routing pro
-	// Mandant (TEN-06, noch nicht gebaut) und wird hier bewusst noch nicht
-	// verdrahtet — Package ist bereits eigenstaendig nutzbar/testbar.
-	superadmins := user.NewSuperadminStore(registryPool)
-	userHandler := user.NewHandler(nil, superadmins)
-
 	mux := http.NewServeMux()
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
-	// Vorlaeufige Pfade ohne Versionierung/Auth — werden mit API-01/IAM-02 abgeloest.
+	// Vorlaeufiger Pfad ohne Versionierung/Auth — wird mit API-01/IAM-01 abgeloest.
 	mux.HandleFunc("/internal/tenants", tenantHandler.CreateTenant)
-	mux.HandleFunc("/internal/superadmins", userHandler.CreateSuperadmin)
 
 	log.Printf("nexarch-core listening on %s", cfg.ListenAddr)
 	if err := http.ListenAndServe(cfg.ListenAddr, mux); err != nil {

internal/audit/audit.go

@@ -0,0 +1,96 @@
+// Package audit implementiert Core AUD-01: das zentrale, vom allgemeinen
+// Anwendungs-Log getrennte Audit-Datenmodell fuer sicherheits- und
+// compliancerelevante Ereignisse (wer, was, wann, an welchem Tenant).
+// Unveraenderlichkeit (Append-only) ist AUD-02, Export/Filter-API ist AUD-03
+// — dieses Paket liefert nur das Datenmodell und den EINEN zentralen
+// Schreibpfad (Akzeptanzkriterium 3).
+package audit
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// SystemTenant ist der reservierte Tenant-Bezug fuer mandantenuebergreifende
+// Ereignisse (z.B. Superadmin-Aktionen) — es gibt bewusst KEINEN Weg, ein
+// Ereignis ganz ohne Tenant-Bezug zu schreiben (Akzeptanzkriterium 2).
+const SystemTenant = "system"
+
+var ErrMissingTenant = errors.New("audit: tenant_slug darf nicht leer sein")
+var ErrMissingActor = errors.New("audit: actor darf nicht leer sein")
+var ErrMissingAction = errors.New("audit: action darf nicht leer sein")
+
+// Event ist ein strukturiertes Audit-Ereignis (Akzeptanzkriterium 1: Akteur,
+// Aktion, Zielobjekt, Zeitpunkt, Tenant).
+type Event struct {
+	TenantSlug string
+	Actor      string
+	Action     string
+	Target     string
+	Metadata   map[string]any
+	OccurredAt time.Time
+}
+
+// Log ist der EINE zentrale Schreibpfad fuer Audit-Ereignisse — es gibt
+// bewusst keine zweite Schreibmoeglichkeit, damit kein Handler versehentlich
+// direkt in audit_events schreibt und dabei die Validierung umgeht
+// (Akzeptanzkriterium 3).
+type Log struct {
+	pool *pgxpool.Pool
+}
+
+func NewLog(pool *pgxpool.Pool) *Log {
+	return &Log{pool: pool}
+}
+
+// Record persistiert genau einen Audit-Eintrag. Fehlender Tenant-Bezug wird
+// bereits hier abgewiesen (klarer Fehler statt Constraint-Verletzung im
+// Normalfall) — die Datenbank-CHECK-Constraint aus der Migration ist die
+// zweite, unumgehbare Verteidigungslinie (Akzeptanzkriterium 2 / Pruefung 2).
+func (l *Log) Record(ctx context.Context, e Event) error {
+	if e.TenantSlug == "" {
+		return ErrMissingTenant
+	}
+	if e.Actor == "" {
+		return ErrMissingActor
+	}
+	if e.Action == "" {
+		return ErrMissingAction
+	}
+	if e.Metadata == nil {
+		e.Metadata = map[string]any{}
+	}
+	metadataJSON, err := json.Marshal(e.Metadata)
+	if err != nil {
+		return fmt.Errorf("metadaten serialisieren: %w", err)
+	}
+	if e.OccurredAt.IsZero() {
+		e.OccurredAt = time.Now()
+	}
+
+	_, err = l.pool.Exec(ctx, `
+		INSERT INTO audit_events (occurred_at, tenant_slug, actor, action, target, metadata)
+		VALUES ($1, $2, $3, $4, $5, $6)
+	`, e.OccurredAt, e.TenantSlug, e.Actor, e.Action, e.Target, metadataJSON)
+	if err != nil {
+		return fmt.Errorf("audit-ereignis schreiben: %w", err)
+	}
+	return nil
+}
+
+// CountByTenant ist eine schlanke Lesehilfe fuer Tests/Diagnose — die
+// eigentliche Filter-/Export-API ist AUD-03, hier bewusst nicht vorgezogen.
+func (l *Log) CountByTenant(ctx context.Context, tenantSlug string) (int, error) {
+	var n int
+	if err := l.pool.QueryRow(ctx, `
+		SELECT count(*) FROM audit_events WHERE tenant_slug = $1
+	`, tenantSlug).Scan(&n); err != nil {
+		return 0, fmt.Errorf("audit-ereignisse zaehlen: %w", err)
+	}
+	return n, nil
+}

internal/audit/audit_test.go

@@ -0,0 +1,132 @@
+package audit
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupAuditTest(t *testing.T) (*Log, *pgxpool.Pool, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS audit_events (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
+			actor TEXT NOT NULL CHECK (actor <> ''),
+			action TEXT NOT NULL CHECK (action <> ''),
+			target TEXT NOT NULL,
+			metadata JSONB NOT NULL DEFAULT '{}'::jsonb
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM audit_events WHERE tenant_slug LIKE 'test\_%' ESCAPE '\' OR tenant_slug = $1`, SystemTenant)
+		pool.Close()
+	}
+	return NewLog(pool), pool, cleanup
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: ein sicherheitsrelevanter Vorgang
+// (hier: fehlgeschlagener Login) erzeugt zuverlaessig genau einen Eintrag.
+func TestRecord_PersistsExactlyOneEventPerSecurityIncident(t *testing.T) {
+	log, pool, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	err := log.Record(ctx, Event{
+		TenantSlug: "test_acme",
+		Actor:      "alice@example.com",
+		Action:     "iam.login_failed",
+		Target:     "user:alice@example.com",
+		Metadata:   map[string]any{"reason": "falsches passwort"},
+	})
+	if err != nil {
+		t.Fatalf("record: %v", err)
+	}
+
+	count, err := log.CountByTenant(ctx, "test_acme")
+	if err != nil {
+		t.Fatalf("count: %v", err)
+	}
+	if count != 1 {
+		t.Fatalf("erwartet genau 1 audit-eintrag, habe %d", count)
+	}
+
+	var actor, action, target string
+	if err := pool.QueryRow(ctx, `
+		SELECT actor, action, target FROM audit_events WHERE tenant_slug = 'test_acme'
+	`).Scan(&actor, &action, &target); err != nil {
+		t.Fatalf("eintrag lesen: %v", err)
+	}
+	if actor != "alice@example.com" || action != "iam.login_failed" || target != "user:alice@example.com" {
+		t.Fatalf("eintrag unerwartet: actor=%q action=%q target=%q", actor, action, target)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2 (App-Ebene): fehlender Tenant-Bezug wird
+// bereits vom zentralen Schreibpfad abgewiesen.
+func TestRecord_RejectsMissingTenant(t *testing.T) {
+	log, _, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	err := log.Record(ctx, Event{TenantSlug: "", Actor: "alice", Action: "irgendwas"})
+	if !errors.Is(err, ErrMissingTenant) {
+		t.Fatalf("erwartet ErrMissingTenant, habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2 (DB-Ebene): selbst ein direkter INSERT,
+// der Log.Record umgeht, wird durch die CHECK-Constraint verhindert — der
+// Schutz haengt nicht allein von der Go-Validierung ab.
+func TestConstraint_RejectsMissingTenantAtDatabaseLevel(t *testing.T) {
+	_, pool, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	_, err := pool.Exec(ctx, `
+		INSERT INTO audit_events (tenant_slug, actor, action, target)
+		VALUES ('', 'alice', 'irgendwas', 'ziel')
+	`)
+	if err == nil {
+		t.Fatal("erwartet fehler durch CHECK-constraint bei leerem tenant_slug, habe nil")
+	}
+}
+
+func TestRecord_RejectsMissingActorAndAction(t *testing.T) {
+	log, _, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := log.Record(ctx, Event{TenantSlug: "test_acme", Actor: "", Action: "x"}); !errors.Is(err, ErrMissingActor) {
+		t.Fatalf("erwartet ErrMissingActor, habe %v", err)
+	}
+	if err := log.Record(ctx, Event{TenantSlug: "test_acme", Actor: "alice", Action: ""}); !errors.Is(err, ErrMissingAction) {
+		t.Fatalf("erwartet ErrMissingAction, habe %v", err)
+	}
+}
+
+func TestRecord_SystemTenantForCrossTenantEvents(t *testing.T) {
+	log, _, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := log.Record(ctx, Event{TenantSlug: SystemTenant, Actor: "superadmin", Action: "tenant.provisioned", Target: "tenant:acme"}); err != nil {
+		t.Fatalf("record mit SystemTenant: %v", err)
+	}
+}

internal/audit/export.go

@@ -0,0 +1,122 @@
+package audit
+
+import (
+	"context"
+	"encoding/csv"
+	"encoding/json"
+	"fmt"
+	"io"
+	"time"
+)
+
+// Filter grenzt einen Export ein (Akzeptanzkriterium 1). Leere/Nil-Felder
+// bedeuten "kein Filter auf diesem Feld".
+type Filter struct {
+	TenantSlug string
+	Actor      string
+	Action     string
+	From       *time.Time
+	To         *time.Time
+}
+
+func buildFilterQuery(f Filter) (string, []any) {
+	query := `SELECT occurred_at, tenant_slug, actor, action, target, metadata FROM audit_events WHERE 1=1`
+	var args []any
+
+	if f.TenantSlug != "" {
+		args = append(args, f.TenantSlug)
+		query += fmt.Sprintf(" AND tenant_slug = $%d", len(args))
+	}
+	if f.Actor != "" {
+		args = append(args, f.Actor)
+		query += fmt.Sprintf(" AND actor = $%d", len(args))
+	}
+	if f.Action != "" {
+		args = append(args, f.Action)
+		query += fmt.Sprintf(" AND action = $%d", len(args))
+	}
+	if f.From != nil {
+		args = append(args, *f.From)
+		query += fmt.Sprintf(" AND occurred_at >= $%d", len(args))
+	}
+	if f.To != nil {
+		args = append(args, *f.To)
+		query += fmt.Sprintf(" AND occurred_at <= $%d", len(args))
+	}
+	query += " ORDER BY occurred_at"
+	return query, args
+}
+
+// StreamCSV schreibt gefilterte Audit-Eintraege direkt als CSV in w, Zeile
+// fuer Zeile ueber rows.Next() — es wird zu keinem Zeitpunkt das gesamte
+// Ergebnis im Speicher aufgebaut (Akzeptanzkriterium 3 / Pruefung 1).
+func (l *Log) StreamCSV(ctx context.Context, filter Filter, w io.Writer) error {
+	query, args := buildFilterQuery(filter)
+	rows, err := l.pool.Query(ctx, query, args...)
+	if err != nil {
+		return fmt.Errorf("export abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	cw := csv.NewWriter(w)
+	if err := cw.Write([]string{"occurred_at", "tenant_slug", "actor", "action", "target", "metadata"}); err != nil {
+		return fmt.Errorf("csv-header schreiben: %w", err)
+	}
+
+	for rows.Next() {
+		var occurredAt time.Time
+		var tenantSlug, actor, action, target string
+		var metadataJSON []byte
+		if err := rows.Scan(&occurredAt, &tenantSlug, &actor, &action, &target, &metadataJSON); err != nil {
+			return fmt.Errorf("zeile lesen: %w", err)
+		}
+		if err := cw.Write([]string{
+			occurredAt.Format(time.RFC3339), tenantSlug, actor, action, target, string(metadataJSON),
+		}); err != nil {
+			return fmt.Errorf("csv-zeile schreiben: %w", err)
+		}
+	}
+	cw.Flush()
+	if err := rows.Err(); err != nil {
+		return fmt.Errorf("export lesen: %w", err)
+	}
+	return cw.Error()
+}
+
+// exportRecord ist die JSON-Repraesentation einer exportierten Zeile.
+type exportRecord struct {
+	OccurredAt time.Time       `json:"occurred_at"`
+	TenantSlug string          `json:"tenant_slug"`
+	Actor      string          `json:"actor"`
+	Action     string          `json:"action"`
+	Target     string          `json:"target"`
+	Metadata   json.RawMessage `json:"metadata"`
+}
+
+// StreamJSON schreibt gefilterte Audit-Eintraege als JSON Lines (ein
+// JSON-Objekt pro Zeile) — bewusst kein einzelnes grosses JSON-Array, da
+// dessen korrektes Streaming (Kommas/Klammern ohne Zwischenpufferung)
+// unnoetige Komplexitaet fuer denselben Zweck waere. Wie StreamCSV
+// zeilenweise ueber rows.Next(), kein Aufbau im Speicher.
+func (l *Log) StreamJSON(ctx context.Context, filter Filter, w io.Writer) error {
+	query, args := buildFilterQuery(filter)
+	rows, err := l.pool.Query(ctx, query, args...)
+	if err != nil {
+		return fmt.Errorf("export abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	enc := json.NewEncoder(w)
+	for rows.Next() {
+		var rec exportRecord
+		var metadataJSON []byte
+		if err := rows.Scan(&rec.OccurredAt, &rec.TenantSlug, &rec.Actor, &rec.Action, &rec.Target, &metadataJSON); err != nil {
+			return fmt.Errorf("zeile lesen: %w", err)
+		}
+		rec.Metadata = metadataJSON
+		if err := enc.Encode(rec); err != nil {
+			return fmt.Errorf("json-zeile schreiben: %w", err)
+		}
+	}
+	return rows.Err()
+}

internal/audit/export_handler.go

@@ -0,0 +1,73 @@
+package audit
+
+import (
+	"context"
+	"net/http"
+	"time"
+)
+
+// Authorize entscheidet, ob caller den Export ausfuehren darf. Die
+// eigentliche Rollen-/Rechtepruefung (RBAC-02 Policy-Enforcement) ist nicht
+// Teil dieser Kachel — ExportHandler kennt nur diese schmale Schnittstelle,
+// analog zum RetentionRegistrar-Muster aus AUD-05.
+type Authorize func(ctx context.Context, caller string) bool
+
+// ExportHandler stellt den Export als HTTP-Endpunkt bereit
+// (Akzeptanzkriterium 2: fuer berechtigte Rollen verfuegbar).
+type ExportHandler struct {
+	log       *Log
+	authorize Authorize
+}
+
+func NewExportHandler(log *Log, authorize Authorize) *ExportHandler {
+	return &ExportHandler{log: log, authorize: authorize}
+}
+
+// Export liest Filter-Query-Parameter (tenant, actor, action, from, to,
+// format) und schreibt DIREKT auf den ResponseWriter (io.Writer) — dieselbe
+// Streaming-Funktion wie in export.go, kein zusaetzlicher Pufferungsschritt.
+func (h *ExportHandler) Export(w http.ResponseWriter, r *http.Request) {
+	// "caller" identifiziert die anfragende Person fuer die Berechtigungs-
+	// pruefung — bewusst getrennt vom Filterfeld "actor" (das den
+	// AUDIT-Akteur meint, ueber den gefiltert wird).
+	caller := r.URL.Query().Get("caller")
+	if caller == "" || !h.authorize(r.Context(), caller) {
+		http.Error(w, "keine berechtigung fuer audit-log-export", http.StatusForbidden)
+		return
+	}
+
+	filter := Filter{
+		TenantSlug: r.URL.Query().Get("tenant"),
+		Actor:      r.URL.Query().Get("actor"),
+		Action:     r.URL.Query().Get("action"),
+	}
+	if from := r.URL.Query().Get("from"); from != "" {
+		t, err := time.Parse(time.RFC3339, from)
+		if err != nil {
+			http.Error(w, "ungueltiges from-datum, erwartet RFC3339", http.StatusBadRequest)
+			return
+		}
+		filter.From = &t
+	}
+	if to := r.URL.Query().Get("to"); to != "" {
+		t, err := time.Parse(time.RFC3339, to)
+		if err != nil {
+			http.Error(w, "ungueltiges to-datum, erwartet RFC3339", http.StatusBadRequest)
+			return
+		}
+		filter.To = &t
+	}
+
+	switch r.URL.Query().Get("format") {
+	case "json":
+		w.Header().Set("Content-Type", "application/x-ndjson")
+		if err := h.log.StreamJSON(r.Context(), filter, w); err != nil {
+			http.Error(w, "export fehlgeschlagen", http.StatusInternalServerError)
+		}
+	default:
+		w.Header().Set("Content-Type", "text/csv")
+		if err := h.log.StreamCSV(r.Context(), filter, w); err != nil {
+			http.Error(w, "export fehlgeschlagen", http.StatusInternalServerError)
+		}
+	}
+}

internal/audit/export_test.go

@@ -0,0 +1,222 @@
+package audit
+
+import (
+	"bytes"
+	"context"
+	"encoding/csv"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupExportTest(t *testing.T) (*Log, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS audit_events (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
+			actor TEXT NOT NULL CHECK (actor <> ''),
+			action TEXT NOT NULL CHECK (action <> ''),
+			target TEXT NOT NULL,
+			metadata JSONB NOT NULL DEFAULT '{}'::jsonb
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewLog(pool), cleanup
+}
+
+// Akzeptanzkriterium 1 + Pruefung 2: Filterkombinationen liefern korrekte
+// Teilmengen.
+func TestExport_FilterCombinations(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	run := fmt.Sprintf("_%d", time.Now().UnixNano())
+	tenantA, tenantB := "test_fa"+run, "test_fb"+run
+	alice, bob := "alice"+run, "bob"+run
+
+	events := []Event{
+		{TenantSlug: tenantA, Actor: alice, Action: "login", Target: "x"},
+		{TenantSlug: tenantA, Actor: bob, Action: "login", Target: "x"},
+		{TenantSlug: tenantA, Actor: alice, Action: "logout", Target: "x"},
+		{TenantSlug: tenantB, Actor: alice, Action: "login", Target: "x"},
+	}
+	for _, e := range events {
+		if err := log.Record(ctx, e); err != nil {
+			t.Fatalf("record: %v", err)
+		}
+	}
+
+	cases := []struct {
+		name    string
+		filter  Filter
+		wantLen int
+	}{
+		{"nach tenant", Filter{TenantSlug: tenantA}, 3},
+		{"nach tenant+actor", Filter{TenantSlug: tenantA, Actor: alice}, 2},
+		{"nach tenant+actor+action", Filter{TenantSlug: tenantA, Actor: alice, Action: "login"}, 1},
+		{"nach actor ueber beide tenants", Filter{Actor: alice, Action: "login"}, 2},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			var buf bytes.Buffer
+			if err := log.StreamCSV(ctx, c.filter, &buf); err != nil {
+				t.Fatalf("stream: %v", err)
+			}
+			rows, err := csv.NewReader(&buf).ReadAll()
+			if err != nil {
+				t.Fatalf("csv parsen: %v", err)
+			}
+			got := len(rows) - 1 // Header abziehen
+			if got != c.wantLen {
+				t.Fatalf("erwartet %d zeilen, habe %d", c.wantLen, got)
+			}
+		})
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 2: Zeitraum-Filter.
+func TestExport_TimeRangeFilter(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	tenant := fmt.Sprintf("test_tr_%d", time.Now().UnixNano())
+	past := time.Now().Add(-48 * time.Hour)
+	future := time.Now().Add(48 * time.Hour)
+
+	if err := log.Record(ctx, Event{TenantSlug: tenant, Actor: "a", Action: "x", Target: "t", OccurredAt: time.Now()}); err != nil {
+		t.Fatalf("record: %v", err)
+	}
+
+	var buf bytes.Buffer
+	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant, From: &past, To: &future}, &buf); err != nil {
+		t.Fatalf("stream (innerhalb range): %v", err)
+	}
+	if got := countLines(buf.String()) - 1; got != 1 {
+		t.Fatalf("erwartet 1 eintrag innerhalb des zeitraums, habe %d", got)
+	}
+
+	farPast := time.Now().Add(-96 * time.Hour)
+	buf.Reset()
+	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant, From: &farPast, To: &past}, &buf); err != nil {
+		t.Fatalf("stream (ausserhalb range): %v", err)
+	}
+	if got := countLines(buf.String()) - 1; got != 0 {
+		t.Fatalf("erwartet 0 eintraege ausserhalb des zeitraums, habe %d", got)
+	}
+}
+
+func countLines(s string) int {
+	s = strings.TrimRight(s, "\n")
+	if s == "" {
+		return 0
+	}
+	return len(strings.Split(s, "\n"))
+}
+
+// Akzeptanzkriterium 3 + Pruefung 1: Export mit hoher Eintragszahl ohne
+// uebermaessigen Speicherverbrauch — Stichprobe per runtime.MemStats.
+func TestExport_StreamsLargeResultWithoutExcessiveMemory(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	tenant := fmt.Sprintf("test_large_%d", time.Now().UnixNano())
+	const n = 20000
+	for i := 0; i < n; i++ {
+		if err := log.Record(ctx, Event{TenantSlug: tenant, Actor: "bulk", Action: "test.bulk", Target: fmt.Sprintf("obj-%d", i)}); err != nil {
+			t.Fatalf("record %d: %v", i, err)
+		}
+	}
+
+	runtime.GC()
+	var before runtime.MemStats
+	runtime.ReadMemStats(&before)
+
+	lineCount := 0
+	cw := &countingWriter{onWrite: func(p []byte) { lineCount += strings.Count(string(p), "\n") }}
+	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant}, cw); err != nil {
+		t.Fatalf("stream: %v", err)
+	}
+
+	runtime.GC()
+	var after runtime.MemStats
+	runtime.ReadMemStats(&after)
+
+	if lineCount != n+1 { // +1 Header
+		t.Fatalf("erwartet %d zeilen (inkl. header), habe %d", n+1, lineCount)
+	}
+
+	// Grobe Stichprobe: ein NICHT streamender Export haette hier locker
+	// mehrere MB an einmal gehaltenen Zeilen/Strings erzeugt. Grosszuegige
+	// Schwelle, da Go-Heap-Messungen naturgemaess rauschen.
+	const maxAcceptableGrowth = 3 * 1024 * 1024 // 3 MB
+	growth := int64(after.HeapAlloc) - int64(before.HeapAlloc)
+	t.Logf("heap-wachstum waehrend export von %d zeilen: %d bytes (schwelle: %d)", n, growth, maxAcceptableGrowth)
+	if growth > maxAcceptableGrowth {
+		t.Fatalf("heap ist um %d bytes gewachsen, erwartet unter %d (hinweis auf vollstaendige pufferung statt streaming)", growth, maxAcceptableGrowth)
+	}
+}
+
+type countingWriter struct {
+	onWrite func(p []byte)
+}
+
+func (w *countingWriter) Write(p []byte) (int, error) {
+	w.onWrite(p)
+	return len(p), nil
+}
+
+// Akzeptanzkriterium 2 + Pruefung 3: Zugriff ohne passende Berechtigung wird abgewiesen.
+func TestExportHandler_RejectsWithoutAuthorization(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+
+	handler := NewExportHandler(log, func(ctx context.Context, caller string) bool {
+		return caller == "berechtigte-person@example.com"
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/audit/export?caller=unberechtigt@example.com", nil)
+	rec := httptest.NewRecorder()
+	handler.Export(rec, req)
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("unberechtigt: status = %d, want 403", rec.Code)
+	}
+
+	reqNoCaller := httptest.NewRequest(http.MethodGet, "/audit/export", nil)
+	recNoCaller := httptest.NewRecorder()
+	handler.Export(recNoCaller, reqNoCaller)
+	if recNoCaller.Code != http.StatusForbidden {
+		t.Fatalf("ohne caller: status = %d, want 403", recNoCaller.Code)
+	}
+
+	reqOK := httptest.NewRequest(http.MethodGet, "/audit/export?caller=berechtigte-person@example.com", nil)
+	recOK := httptest.NewRecorder()
+	handler.Export(recOK, reqOK)
+	if recOK.Code != http.StatusOK {
+		t.Fatalf("berechtigt: status = %d, want 200", recOK.Code)
+	}
+}

internal/policy/enforcer.go

@@ -1,67 +0,0 @@
-package policy
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-)
-
-// ErrDenied wird geliefert, wenn keine Regel role+permission erlaubt —
-// Default-Deny (Akzeptanzkriterium 2).
-var ErrDenied = errors.New("policy: zugriff verweigert")
-
-// Enforcer ist die EINE zentrale Entscheidungs- und Durchsetzungsschicht
-// (Akzeptanzkriterium 1). Repository-/Query-Code ruft ausschliesslich Guard
-// bzw. GuardTenantScoped auf, nie eine Rohabfrage direkt.
-type Enforcer struct {
-	store *Store
-}
-
-func NewEnforcer(store *Store) *Enforcer {
-	return &Enforcer{store: store}
-}
-
-// Authorize entscheidet erlaubt/verboten — unabhaengig von jeder konkreten
-// Query, rein anhand der deklarativen Regeln (Akzeptanzkriterium 2: fuer
-// sich genommen testbar, ohne Anwendungslogik).
-func (e *Enforcer) Authorize(ctx context.Context, role rbac.Role, perm rbac.Permission) error {
-	allowed, err := e.store.IsAllowed(ctx, role, perm)
-	if err != nil {
-		return err
-	}
-	if !allowed {
-		return fmt.Errorf("%w: rolle %q hat kein recht %q", ErrDenied, role, perm)
-	}
-	return nil
-}
-
-// Guard ist die zentrale Enforcement-Funktion (Akzeptanzkriterium 1): query
-// wird NUR aufgerufen, wenn Authorize zustimmt. Es gibt keinen Weg, query
-// ausserhalb von Guard aufzurufen und trotzdem den Aufrufer als autorisiert
-// zu behandeln — die Autorisierungsentscheidung steht immer VOR dem
-// Datenzugriff, nie danach.
-func Guard[T any](ctx context.Context, e *Enforcer, role rbac.Role, perm rbac.Permission, query func(ctx context.Context) (T, error)) (T, error) {
-	var zero T
-	if err := e.Authorize(ctx, role, perm); err != nil {
-		return zero, err
-	}
-	return query(ctx)
-}
-
-// GuardTenantScoped erzwingt zusaetzlich, dass tenantSlug TEIL der Query-
-// Funktion selbst ist (Akzeptanzkriterium 3): der Funktionstyp verlangt,
-// dass die Repository-Implementierung tenantSlug in ihre eigene WHERE-
-// Klausel einbaut — ein nachgelagerter Filter auf dem Ergebnis (der
-// archivmail-Fehler aus "Bekannte Fehler vermeiden") ist mit dieser
-// Signatur nicht moeglich, da die Query-Funktion tenantSlug selbst
-// entgegennimmt und dafuer verantwortlich ist, statt ihn hinterher
-// anzuwenden.
-func GuardTenantScoped[T any](ctx context.Context, e *Enforcer, role rbac.Role, perm rbac.Permission, tenantSlug string, query func(ctx context.Context, tenantSlug string) (T, error)) (T, error) {
-	var zero T
-	if err := e.Authorize(ctx, role, perm); err != nil {
-		return zero, err
-	}
-	return query(ctx, tenantSlug)
-}

internal/policy/policy_test.go

@@ -1,187 +0,0 @@
-package policy
-
-import (
-	"context"
-	"errors"
-	"os"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-)
-
-func setupTest(t *testing.T) (*Store, *Enforcer, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS policy_rules (
-			role TEXT NOT NULL, permission TEXT NOT NULL,
-			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-			PRIMARY KEY (role, permission)
-		);
-		CREATE TABLE IF NOT EXISTS policy_rule_changes (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), role TEXT NOT NULL, permission TEXT NOT NULL,
-			action TEXT NOT NULL CHECK (action IN ('grant','revoke')), actor TEXT NOT NULL,
-			version INT NOT NULL, changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	store := NewStore(pool)
-	cleanup := func() {
-		_, _ = pool.Exec(ctx, `DELETE FROM policy_rule_changes WHERE role LIKE 'test\_%' ESCAPE '\'`)
-		_, _ = pool.Exec(ctx, `DELETE FROM policy_rules WHERE role LIKE 'test\_%' ESCAPE '\'`)
-		pool.Close()
-	}
-	return store, NewEnforcer(store), cleanup
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: Anfrage ohne passende Policy wird
-// zuverlaessig abgewiesen (Default-Deny), nicht standardmaessig erlaubt.
-func TestAuthorize_DefaultDeny(t *testing.T) {
-	_, enforcer, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	err := enforcer.Authorize(ctx, rbac.Role("test_niemand"), rbac.Permission("test_irgendwas"))
-	if !errors.Is(err, ErrDenied) {
-		t.Fatalf("erwartet ErrDenied ohne konfigurierte regel, habe %v", err)
-	}
-}
-
-// Akzeptanzkriterium 1 + Pruefung 1: Guard ruft query NUR bei Autorisierung
-// auf — kein Datenzugriffs-Pfad umgeht die Enforcement-Schicht.
-func TestGuard_NeverCallsQueryWithoutAuthorization(t *testing.T) {
-	store, enforcer, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	role := rbac.Role("test_rolle_guard")
-	perm := rbac.Permission("test_lesen")
-
-	queryCalled := false
-	_, err := Guard(ctx, enforcer, role, perm, func(ctx context.Context) (string, error) {
-		queryCalled = true
-		return "geheime-daten", nil
-	})
-	if !errors.Is(err, ErrDenied) {
-		t.Fatalf("erwartet ErrDenied, habe %v", err)
-	}
-	if queryCalled {
-		t.Fatal("query haette bei fehlender autorisierung NICHT aufgerufen werden duerfen")
-	}
-
-	if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
-		t.Fatalf("grant: %v", err)
-	}
-
-	result, err := Guard(ctx, enforcer, role, perm, func(ctx context.Context) (string, error) {
-		queryCalled = true
-		return "geheime-daten", nil
-	})
-	if err != nil {
-		t.Fatalf("guard nach grant: %v", err)
-	}
-	if !queryCalled || result != "geheime-daten" {
-		t.Fatalf("erwartet query-aufruf mit ergebnis nach autorisierung, habe queryCalled=%v result=%q", queryCalled, result)
-	}
-}
-
-// Akzeptanzkriterium 2 + 3: Policy-Entscheidungen deklarativ und unabhaengig
-// von Anwendungslogik testbar — Regelwechsel wirkt ohne Codeaenderung,
-// Historie ist versioniert nachvollziehbar.
-func TestGrantRevoke_ChangesBehaviorWithoutCodeChange(t *testing.T) {
-	store, enforcer, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	role := rbac.Role("test_rolle_history")
-	perm := rbac.Permission("test_schreiben")
-
-	allowed, err := store.IsAllowed(ctx, role, perm)
-	if err != nil {
-		t.Fatalf("is allowed (vorher): %v", err)
-	}
-	if allowed {
-		t.Fatal("erwartet nicht erlaubt vor grant")
-	}
-
-	if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
-		t.Fatalf("grant: %v", err)
-	}
-	if err := enforcer.Authorize(ctx, role, perm); err != nil {
-		t.Fatalf("authorize nach grant sollte erlauben: %v", err)
-	}
-
-	if err := store.Revoke(ctx, role, perm, "admin@example.com"); err != nil {
-		t.Fatalf("revoke: %v", err)
-	}
-	if err := enforcer.Authorize(ctx, role, perm); !errors.Is(err, ErrDenied) {
-		t.Fatalf("authorize nach revoke sollte verweigern, habe %v", err)
-	}
-
-	history, err := store.History(ctx, role, perm)
-	if err != nil {
-		t.Fatalf("history: %v", err)
-	}
-	if len(history) != 2 {
-		t.Fatalf("erwartet 2 historieneintraege (grant, revoke), habe %d", len(history))
-	}
-	if history[0].Action != "grant" || history[0].Version != 1 {
-		t.Fatalf("history[0] unerwartet: %+v", history[0])
-	}
-	if history[1].Action != "revoke" || history[1].Version != 2 {
-		t.Fatalf("history[1] unerwartet: %+v", history[1])
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 3 (Tenant-Scoping): GuardTenantScoped
-// zwingt tenantSlug in die Query-Funktion selbst, kein Post-Filter moeglich.
-func TestGuardTenantScoped_IsolatesDataBetweenTenants(t *testing.T) {
-	_, enforcer, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	// Simuliertes Repository: die WHERE-Klausel (hier: Map-Lookup) liegt
-	// INNERHALB der Query-Funktion, nicht als nachgelagerter Filter.
-	data := map[string][]string{
-		"acme":   {"dokument-a1", "dokument-a2"},
-		"globex": {"dokument-b1"},
-	}
-	repoQuery := func(ctx context.Context, tenantSlug string) ([]string, error) {
-		return data[tenantSlug], nil
-	}
-
-	role := rbac.Role("test_tenant_rolle")
-	perm := rbac.Permission("test_dokumente_lesen")
-	if err := enforcer.store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
-		t.Fatalf("grant: %v", err)
-	}
-
-	gotAcme, err := GuardTenantScoped(ctx, enforcer, role, perm, "acme", repoQuery)
-	if err != nil {
-		t.Fatalf("guard tenant scoped (acme): %v", err)
-	}
-	if len(gotAcme) != 2 {
-		t.Fatalf("erwartet 2 dokumente fuer acme, habe %d", len(gotAcme))
-	}
-
-	gotGlobex, err := GuardTenantScoped(ctx, enforcer, role, perm, "globex", repoQuery)
-	if err != nil {
-		t.Fatalf("guard tenant scoped (globex): %v", err)
-	}
-	if len(gotGlobex) != 1 {
-		t.Fatalf("erwartet 1 dokument fuer globex, habe %d", len(gotGlobex))
-	}
-}

internal/policy/store.go

@@ -1,124 +0,0 @@
-// Package policy implementiert Core RBAC-02: die zentrale Policy-
-// Entscheidungs- und Durchsetzungsschicht. Regeln liegen deklarativ in der
-// Datenbank (Casbin-Prinzip: Policy als Modell+Regeln getrennt vom Code),
-// versioniert und auditierbar — anders als Casbin-Dateien im Dateisystem
-// (siehe "bewusst vermeiden" im Ticket).
-package policy
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-)
-
-// Rule ist eine gewaehrte Regel: role darf permission.
-type Rule struct {
-	Role       rbac.Role
-	Permission rbac.Permission
-}
-
-// RuleChange ist ein Eintrag der Aenderungshistorie (Akzeptanzkriterium 3).
-type RuleChange struct {
-	Role       rbac.Role
-	Permission rbac.Permission
-	Action     string // "grant" oder "revoke"
-	Actor      string
-	Version    int
-}
-
-// Store verwaltet den deklarativen Regelsatz. IsAllowed schaut NUR in die
-// Datenbank — es gibt keinen hartcodierten Go-Fallback, ein Regelwechsel
-// wirkt sich ohne Codeaenderung sofort aus (Akzeptanzkriterium 2 / 3).
-type Store struct {
-	pool *pgxpool.Pool
-}
-
-func NewStore(pool *pgxpool.Pool) *Store {
-	return &Store{pool: pool}
-}
-
-// IsAllowed prueft, ob role das Recht permission besitzt. Default-Deny:
-// existiert keine passende Regel, ist der Zugriff verboten
-// (Akzeptanzkriterium 2 / Pruefung 2) — es gibt keinen impliziten
-// "erlaubt, wenn nichts anderes gesagt"-Pfad.
-func (s *Store) IsAllowed(ctx context.Context, role rbac.Role, perm rbac.Permission) (bool, error) {
-	var exists bool
-	err := s.pool.QueryRow(ctx, `
-		SELECT EXISTS(SELECT 1 FROM policy_rules WHERE role = $1 AND permission = $2)
-	`, string(role), string(perm)).Scan(&exists)
-	if err != nil {
-		return false, fmt.Errorf("policy pruefen: %w", err)
-	}
-	return exists, nil
-}
-
-// Grant gewaehrt role das Recht permission — deklarativ, ohne Codeaenderung
-// wirksam. actor wird fuer die Aenderungshistorie festgehalten.
-func (s *Store) Grant(ctx context.Context, role rbac.Role, perm rbac.Permission, actor string) error {
-	return s.change(ctx, role, perm, "grant", actor, `
-		INSERT INTO policy_rules (role, permission, granted_by, granted_at)
-		VALUES ($1, $2, $3, now())
-		ON CONFLICT (role, permission) DO UPDATE SET granted_by = $3, granted_at = now()
-	`, string(role), string(perm), actor)
-}
-
-// Revoke entzieht role das Recht permission.
-func (s *Store) Revoke(ctx context.Context, role rbac.Role, perm rbac.Permission, actor string) error {
-	return s.change(ctx, role, perm, "revoke", actor, `
-		DELETE FROM policy_rules WHERE role = $1 AND permission = $2
-	`, string(role), string(perm))
-}
-
-func (s *Store) change(ctx context.Context, role rbac.Role, perm rbac.Permission, action, actor, sql string, args ...any) error {
-	tx, err := s.pool.Begin(ctx)
-	if err != nil {
-		return fmt.Errorf("transaktion starten: %w", err)
-	}
-	defer func() { _ = tx.Rollback(ctx) }()
-
-	if _, err := tx.Exec(ctx, sql, args...); err != nil {
-		return fmt.Errorf("regel aendern: %w", err)
-	}
-
-	var version int
-	if err := tx.QueryRow(ctx, `
-		SELECT COALESCE(MAX(version), 0) + 1 FROM policy_rule_changes WHERE role = $1 AND permission = $2
-	`, string(role), string(perm)).Scan(&version); err != nil {
-		return fmt.Errorf("naechste version ermitteln: %w", err)
-	}
-
-	if _, err := tx.Exec(ctx, `
-		INSERT INTO policy_rule_changes (role, permission, action, actor, version, changed_at)
-		VALUES ($1, $2, $3, $4, $5, now())
-	`, string(role), string(perm), action, actor, version); err != nil {
-		return fmt.Errorf("historie schreiben: %w", err)
-	}
-
-	return tx.Commit(ctx)
-}
-
-// History liefert die vollstaendige, versionierte Aenderungshistorie einer
-// Regel (Akzeptanzkriterium 3).
-func (s *Store) History(ctx context.Context, role rbac.Role, perm rbac.Permission) ([]RuleChange, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT action, actor, version FROM policy_rule_changes
-		WHERE role = $1 AND permission = $2 ORDER BY version
-	`, string(role), string(perm))
-	if err != nil {
-		return nil, fmt.Errorf("historie abfragen: %w", err)
-	}
-	defer rows.Close()
-
-	var out []RuleChange
-	for rows.Next() {
-		c := RuleChange{Role: role, Permission: perm}
-		if err := rows.Scan(&c.Action, &c.Actor, &c.Version); err != nil {
-			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
-		}
-		out = append(out, c)
-	}
-	return out, rows.Err()
-}

internal/rbac/role.go

@@ -1,71 +0,0 @@
-// Package rbac implementiert Core RBAC-01: das Rollenmodell mit
-// Grundrollen/-rechten, Hierarchie und Zuweisung. Die eigentliche
-// Durchsetzung (erlaubt/verboten je Request) ist RBAC-02, dieses Paket
-// liefert nur Modell + Zuweisung (Casbin-Prinzip: Policy-Modell getrennt
-// von der Entscheidungsfunktion).
-package rbac
-
-// Role ist eine der drei Grundrollen. Superadmin lebt mandantenuebergreifend
-// (siehe internal/user.SuperadminStore aus IAM-01) und wird deshalb NICHT
-// ueber Store (tenant-gescoped) zugewiesen — die Existenz eines Superadmin-
-// Kontos IST die Rollenzuweisung.
-type Role string
-
-const (
-	RoleSuperadmin  Role = "superadmin"
-	RoleTenantAdmin Role = "tenant_admin"
-	RoleUser        Role = "user"
-)
-
-type Permission string
-
-const (
-	PermSelfRead       Permission = "self.read"
-	PermSelfUpdate     Permission = "self.update"
-	PermManageUsers    Permission = "tenant.manage_users"
-	PermManageSettings Permission = "tenant.manage_settings"
-	PermManageTenants  Permission = "platform.manage_tenants"
-)
-
-// parent bildet die Rollenhierarchie ab (Akzeptanzkriterium 2): eine Rolle
-// erbt alle Rechte ihrer Elternrolle. tenant_admin erbt von user,
-// superadmin erbt von tenant_admin.
-var parent = map[Role]Role{
-	RoleTenantAdmin: RoleUser,
-	RoleSuperadmin:  RoleTenantAdmin,
-}
-
-// direct sind die einer Rolle direkt (ohne Vererbung) zugeordneten Rechte.
-var direct = map[Role][]Permission{
-	RoleUser:        {PermSelfRead, PermSelfUpdate},
-	RoleTenantAdmin: {PermManageUsers, PermManageSettings},
-	RoleSuperadmin:  {PermManageTenants},
-}
-
-// EffectivePermissions liefert die vollstaendige, ueber die Hierarchie
-// aufgeloeste Rechtemenge einer Rolle (Akzeptanzkriterium 2 / Pruefung 2).
-func EffectivePermissions(role Role) []Permission {
-	seen := make(map[Permission]bool)
-	var out []Permission
-
-	for r, ok := role, true; ok; r, ok = parent[r] {
-		for _, p := range direct[r] {
-			if !seen[p] {
-				seen[p] = true
-				out = append(out, p)
-			}
-		}
-	}
-	return out
-}
-
-// HasPermission prueft, ob eine Rolle (inklusive geerbter Rechte) ein
-// bestimmtes Recht besitzt.
-func HasPermission(role Role, perm Permission) bool {
-	for _, p := range EffectivePermissions(role) {
-		if p == perm {
-			return true
-		}
-	}
-	return false
-}

internal/rbac/role_test.go

@@ -1,48 +0,0 @@
-package rbac
-
-import "testing"
-
-func contains(perms []Permission, p Permission) bool {
-	for _, x := range perms {
-		if x == p {
-			return true
-		}
-	}
-	return false
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: Rollenhierarchie liefert die erwartete
-// effektive Rechtemenge.
-func TestEffectivePermissions_Inheritance(t *testing.T) {
-	userPerms := EffectivePermissions(RoleUser)
-	if !contains(userPerms, PermSelfRead) || !contains(userPerms, PermSelfUpdate) {
-		t.Fatalf("user sollte self.read/self.update haben, habe %v", userPerms)
-	}
-	if contains(userPerms, PermManageUsers) {
-		t.Fatal("user sollte KEIN tenant.manage_users haben")
-	}
-
-	adminPerms := EffectivePermissions(RoleTenantAdmin)
-	if !contains(adminPerms, PermSelfRead) || !contains(adminPerms, PermManageUsers) || !contains(adminPerms, PermManageSettings) {
-		t.Fatalf("tenant_admin sollte geerbte user-rechte + eigene rechte haben, habe %v", adminPerms)
-	}
-	if contains(adminPerms, PermManageTenants) {
-		t.Fatal("tenant_admin sollte KEIN platform.manage_tenants haben")
-	}
-
-	superPerms := EffectivePermissions(RoleSuperadmin)
-	for _, want := range []Permission{PermSelfRead, PermSelfUpdate, PermManageUsers, PermManageSettings, PermManageTenants} {
-		if !contains(superPerms, want) {
-			t.Fatalf("superadmin sollte %q haben (volle vererbte kette), habe %v", want, superPerms)
-		}
-	}
-}
-
-func TestHasPermission(t *testing.T) {
-	if !HasPermission(RoleTenantAdmin, PermSelfRead) {
-		t.Fatal("tenant_admin sollte geerbtes self.read haben")
-	}
-	if HasPermission(RoleUser, PermManageTenants) {
-		t.Fatal("user sollte platform.manage_tenants nicht haben")
-	}
-}

internal/rbac/store.go

@@ -1,124 +0,0 @@
-package rbac
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var (
-	// ErrRoleNotAssignableInTenantScope wird geliefert, wenn versucht wird,
-	// eine mandantenuebergreifende Rolle (superadmin) ueber den tenant-
-	// gescopten Store zu vergeben — die erlaubte Matrix laesst hier nur
-	// user/tenant_admin zu (Akzeptanzkriterium 1 / Pruefung 1).
-	ErrRoleNotAssignableInTenantScope = errors.New("rbac: rolle ist in diesem geltungsbereich nicht zuweisbar")
-	ErrNotFound                       = errors.New("rbac: keine rollenzuweisung gefunden")
-)
-
-// assignableRoles ist die erlaubte Matrix fuer Store (tenant-gescoped).
-var assignableRoles = map[Role]bool{
-	RoleUser:        true,
-	RoleTenantAdmin: true,
-}
-
-type Assignment struct {
-	UserID    string
-	Role      Role
-	GrantedBy string
-}
-
-// Store verwaltet Rollenzuweisungen innerhalb GENAU EINER Tenant-Datenbank —
-// analog zu internal/user.TenantUserStore (Modell C: der Pool bestimmt den
-// Tenant, keine tenant_id-Spalte noetig).
-type Store struct {
-	pool *pgxpool.Pool
-}
-
-func NewStore(pool *pgxpool.Pool) *Store {
-	return &Store{pool: pool}
-}
-
-// Assign vergibt eine Rolle an einen Benutzer. grantedBy identifiziert den
-// Akteur, der die Zuweisung vorgenommen hat (Akzeptanzkriterium 3). Jede
-// Zuweisung wird zusaetzlich in role_assignment_history festgehalten, auch
-// wenn sie eine vorherige Rolle ersetzt.
-func (s *Store) Assign(ctx context.Context, userID string, role Role, grantedBy string) (Assignment, error) {
-	if !assignableRoles[role] {
-		return Assignment{}, ErrRoleNotAssignableInTenantScope
-	}
-	if grantedBy == "" {
-		return Assignment{}, errors.New("rbac: grantedBy darf nicht leer sein")
-	}
-
-	tx, err := s.pool.Begin(ctx)
-	if err != nil {
-		return Assignment{}, fmt.Errorf("transaktion starten: %w", err)
-	}
-	defer func() { _ = tx.Rollback(ctx) }()
-
-	if _, err := tx.Exec(ctx, `
-		INSERT INTO role_assignments (user_id, role, granted_by, granted_at)
-		VALUES ($1, $2, $3, now())
-		ON CONFLICT (user_id) DO UPDATE SET role = $2, granted_by = $3, granted_at = now()
-	`, userID, string(role), grantedBy); err != nil {
-		return Assignment{}, fmt.Errorf("rolle zuweisen: %w", err)
-	}
-
-	if _, err := tx.Exec(ctx, `
-		INSERT INTO role_assignment_history (user_id, role, granted_by, granted_at)
-		VALUES ($1, $2, $3, now())
-	`, userID, string(role), grantedBy); err != nil {
-		return Assignment{}, fmt.Errorf("historie schreiben: %w", err)
-	}
-
-	if err := tx.Commit(ctx); err != nil {
-		return Assignment{}, fmt.Errorf("transaktion committen: %w", err)
-	}
-
-	return Assignment{UserID: userID, Role: role, GrantedBy: grantedBy}, nil
-}
-
-func (s *Store) Get(ctx context.Context, userID string) (Assignment, error) {
-	var a Assignment
-	var role string
-	a.UserID = userID
-	if err := s.pool.QueryRow(ctx, `
-		SELECT role, granted_by FROM role_assignments WHERE user_id = $1
-	`, userID).Scan(&role, &a.GrantedBy); err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return Assignment{}, ErrNotFound
-		}
-		return Assignment{}, fmt.Errorf("rollenzuweisung lesen: %w", err)
-	}
-	a.Role = Role(role)
-	return a, nil
-}
-
-// History liefert jede Rollenzuweisung eines Benutzers in chronologischer
-// Reihenfolge — die Grundlage fuer "wer hat wann welche Rolle vergeben"
-// (Akzeptanzkriterium 3).
-func (s *Store) History(ctx context.Context, userID string) ([]Assignment, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT role, granted_by FROM role_assignment_history
-		WHERE user_id = $1 ORDER BY granted_at
-	`, userID)
-	if err != nil {
-		return nil, fmt.Errorf("historie abfragen: %w", err)
-	}
-	defer rows.Close()
-
-	var out []Assignment
-	for rows.Next() {
-		var role string
-		a := Assignment{UserID: userID}
-		if err := rows.Scan(&role, &a.GrantedBy); err != nil {
-			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
-		}
-		a.Role = Role(role)
-		out = append(out, a)
-	}
-	return out, rows.Err()
-}

internal/rbac/store_test.go

@@ -1,144 +0,0 @@
-package rbac
-
-import (
-	"context"
-	"errors"
-	"os"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
-)
-
-func setupStoreTest(t *testing.T) (*Store, string, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS users (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			email TEXT NOT NULL UNIQUE,
-			name TEXT NOT NULL,
-			status TEXT NOT NULL DEFAULT 'active',
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS role_assignments (
-			user_id UUID PRIMARY KEY REFERENCES users(id),
-			role TEXT NOT NULL CHECK (role IN ('user', 'tenant_admin')),
-			granted_by TEXT NOT NULL,
-			granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS role_assignment_history (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			user_id UUID NOT NULL,
-			role TEXT NOT NULL,
-			granted_by TEXT NOT NULL,
-			granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	userStore := user.NewTenantUserStore(pool)
-	u, err := userStore.Create(ctx, "rbac_test@example.com", "RBAC Test")
-	if err != nil {
-		t.Fatalf("testuser anlegen: %v", err)
-	}
-
-	cleanup := func() {
-		_, _ = pool.Exec(ctx, `DELETE FROM role_assignment_history WHERE user_id = $1`, u.ID)
-		_, _ = pool.Exec(ctx, `DELETE FROM role_assignments WHERE user_id = $1`, u.ID)
-		_, _ = pool.Exec(ctx, `DELETE FROM users WHERE id = $1`, u.ID)
-		pool.Close()
-	}
-	return NewStore(pool), u.ID, cleanup
-}
-
-// Akzeptanzkriterium 1: Grundrollen sind einem Benutzer je Tenant zuweisbar.
-func TestStore_AssignAndGet(t *testing.T) {
-	store, userID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	assigned, err := store.Assign(ctx, userID, RoleTenantAdmin, "admin@acme.example")
-	if err != nil {
-		t.Fatalf("assign: %v", err)
-	}
-	if assigned.Role != RoleTenantAdmin {
-		t.Fatalf("erwartet tenant_admin, habe %q", assigned.Role)
-	}
-
-	got, err := store.Get(ctx, userID)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if got.Role != RoleTenantAdmin || got.GrantedBy != "admin@acme.example" {
-		t.Fatalf("zuweisung unerwartet: %+v", got)
-	}
-}
-
-// Akzeptanzkriterium 1 + Pruefung 1: Zuweisung ausserhalb der erlaubten
-// Matrix (superadmin im tenant-gescopten Store) wird abgewiesen.
-func TestStore_RejectsSuperadminOutsideAllowedMatrix(t *testing.T) {
-	store, userID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	_, err := store.Assign(ctx, userID, RoleSuperadmin, "admin@acme.example")
-	if !errors.Is(err, ErrRoleNotAssignableInTenantScope) {
-		t.Fatalf("erwartet ErrRoleNotAssignableInTenantScope, habe %v", err)
-	}
-
-	// Sicherstellen, dass der abgewiesene Versuch keine Zeile hinterlassen hat.
-	if _, err := store.Get(ctx, userID); !errors.Is(err, ErrNotFound) {
-		t.Fatalf("erwartet ErrNotFound nach abgewiesener zuweisung, habe %v", err)
-	}
-}
-
-func TestStore_RejectsUnknownRole(t *testing.T) {
-	store, userID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := store.Assign(ctx, userID, Role("erfunden"), "admin@acme.example"); !errors.Is(err, ErrRoleNotAssignableInTenantScope) {
-		t.Fatalf("erwartet ErrRoleNotAssignableInTenantScope fuer unbekannte rolle, habe %v", err)
-	}
-}
-
-// Akzeptanzkriterium 3: Rollenzuweisung vollstaendig auditierbar.
-func TestStore_HistoryTracksWhoAndWhen(t *testing.T) {
-	store, userID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := store.Assign(ctx, userID, RoleUser, "system"); err != nil {
-		t.Fatalf("assign 1: %v", err)
-	}
-	if _, err := store.Assign(ctx, userID, RoleTenantAdmin, "admin@acme.example"); err != nil {
-		t.Fatalf("assign 2: %v", err)
-	}
-
-	history, err := store.History(ctx, userID)
-	if err != nil {
-		t.Fatalf("history: %v", err)
-	}
-	if len(history) != 2 {
-		t.Fatalf("erwartet 2 historieneintraege, habe %d", len(history))
-	}
-	if history[0].Role != RoleUser || history[0].GrantedBy != "system" {
-		t.Fatalf("history[0] unerwartet: %+v", history[0])
-	}
-	if history[1].Role != RoleTenantAdmin || history[1].GrantedBy != "admin@acme.example" {
-		t.Fatalf("history[1] unerwartet: %+v", history[1])
-	}
-}

internal/user/handler.go

@@ -1,66 +0,0 @@
-package user
-
-import (
-	"encoding/json"
-	"errors"
-	"net/http"
-)
-
-// Handler stellt die CRUD-API fuer Benutzerkonten bereit (IAM-01-Auftrag).
-// Auth/Sessions (IAM-02) und Rollen (RBAC-01) sind ausdruecklich nicht Teil
-// dieser Kachel und daher hier noch nicht angebunden.
-type Handler struct {
-	users       *TenantUserStore
-	superadmins *SuperadminStore
-}
-
-func NewHandler(users *TenantUserStore, superadmins *SuperadminStore) *Handler {
-	return &Handler{users: users, superadmins: superadmins}
-}
-
-type createUserRequest struct {
-	Email string `json:"email"`
-	Name  string `json:"name"`
-}
-
-func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
-	var req createUserRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
-		return
-	}
-
-	u, err := h.users.Create(r.Context(), req.Email, req.Name)
-	writeUserResult(w, u, err)
-}
-
-// CreateSuperadmin legt ein mandantenuebergreifendes Superadmin-Konto an —
-// bewusst ein eigener Endpunkt statt eines Tenant-Parameters mit Null-Wert.
-func (h *Handler) CreateSuperadmin(w http.ResponseWriter, r *http.Request) {
-	var req createUserRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
-		return
-	}
-
-	u, err := h.superadmins.Create(r.Context(), req.Email, req.Name)
-	writeUserResult(w, u, err)
-}
-
-func writeUserResult(w http.ResponseWriter, u User, err error) {
-	if err != nil {
-		switch {
-		case errors.Is(err, ErrInvalidEmail), errors.Is(err, ErrEmailTaken):
-			http.Error(w, err.Error(), http.StatusBadRequest)
-		case errors.Is(err, ErrNotFound):
-			http.Error(w, err.Error(), http.StatusNotFound)
-		default:
-			http.Error(w, "benutzer konnte nicht verarbeitet werden", http.StatusInternalServerError)
-		}
-		return
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusCreated)
-	_ = json.NewEncoder(w).Encode(u)
-}

internal/user/store_test.go

@@ -1,173 +0,0 @@
-package user
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// setupTestDB legt eine frische, isolierte Testdatenbank an, wendet die
-// uebergebene Migration an und liefert einen verbundenen Pool. Wird ohne
-// TEST_ADMIN_DSN uebersprungen — siehe internal/tenant/provisioner_test.go
-// fuer dasselbe Muster.
-func setupTestDB(t *testing.T, dbName, schemaSQL string) *pgxpool.Pool {
-	t.Helper()
-
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	adminPool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("admin pool: %v", err)
-	}
-
-	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
-	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
-		t.Fatalf("testdatenbank anlegen: %v", err)
-	}
-
-	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
-	pool, err := pgxpool.New(ctx, dsn)
-	if err != nil {
-		t.Fatalf("connect testdatenbank: %v", err)
-	}
-
-	if _, err := pool.Exec(ctx, schemaSQL); err != nil {
-		t.Fatalf("schema anwenden: %v", err)
-	}
-
-	t.Cleanup(func() {
-		pool.Close()
-		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
-		adminPool.Close()
-	})
-
-	return pool
-}
-
-const usersSchema = `
-CREATE EXTENSION IF NOT EXISTS pgcrypto;
-CREATE TABLE users (
-	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-	email TEXT NOT NULL UNIQUE,
-	name TEXT NOT NULL,
-	status TEXT NOT NULL DEFAULT 'active',
-	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);`
-
-const superadminsSchema = `
-CREATE EXTENSION IF NOT EXISTS pgcrypto;
-CREATE TABLE superadmins (
-	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-	email TEXT NOT NULL UNIQUE,
-	name TEXT NOT NULL,
-	status TEXT NOT NULL DEFAULT 'active',
-	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);`
-
-// Akzeptanzkriterium 1 + 3, Pruefung 1 (inkl. Negativfall doppelte E-Mail).
-func TestTenantUserStore_CRUD(t *testing.T) {
-	pool := setupTestDB(t, "test_iam01_users", usersSchema)
-	store := NewTenantUserStore(pool)
-	ctx := context.Background()
-
-	created, err := store.Create(ctx, "alice@example.com", "Alice")
-	if err != nil {
-		t.Fatalf("create: %v", err)
-	}
-	if created.Status != StatusActive {
-		t.Fatalf("erwartet status active, hat %q", created.Status)
-	}
-
-	got, err := store.Get(ctx, created.ID)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if got.Email != "alice@example.com" {
-		t.Fatalf("get email = %q", got.Email)
-	}
-
-	updated, err := store.Update(ctx, created.ID, "", "Alice A.")
-	if err != nil {
-		t.Fatalf("update: %v", err)
-	}
-	if updated.Name != "Alice A." || updated.Email != "alice@example.com" {
-		t.Fatalf("update ergebnis unerwartet: %+v", updated)
-	}
-
-	list, err := store.List(ctx)
-	if err != nil {
-		t.Fatalf("list: %v", err)
-	}
-	if len(list) != 1 {
-		t.Fatalf("erwartet 1 benutzer, habe %d", len(list))
-	}
-
-	deactivated, err := store.Deactivate(ctx, created.ID)
-	if err != nil {
-		t.Fatalf("deactivate: %v", err)
-	}
-	if deactivated.Status != StatusInactive {
-		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
-	}
-
-	// Negativfall: doppelte E-Mail-Adresse.
-	if _, err := store.Create(ctx, "second@example.com", "Bob"); err != nil {
-		t.Fatalf("create second: %v", err)
-	}
-	if _, err := store.Create(ctx, "second@example.com", "Bob Zwei"); !errors.Is(err, ErrEmailTaken) {
-		t.Fatalf("erwartet ErrEmailTaken, habe %v", err)
-	}
-
-	// Negativfall: fehlender Benutzer.
-	if _, err := store.Get(ctx, created.ID+"-nicht-vorhanden"); err == nil {
-		t.Fatalf("erwartet fehler bei unbekannter/ungueltiger id")
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: Superadmin-Anlage ohne Tenant-Kontext.
-// SuperadminStore.Create hat keinen Tenant-Parameter — es gibt syntaktisch
-// keine Moeglichkeit, hier versehentlich einen Tenant-Sonderfall zu vergessen.
-func TestSuperadminStore_CreateWithoutTenantContext(t *testing.T) {
-	pool := setupTestDB(t, "test_iam01_superadmins", superadminsSchema)
-	store := NewSuperadminStore(pool)
-	ctx := context.Background()
-
-	created, err := store.Create(ctx, "root@nexarch.internal", "Root")
-	if err != nil {
-		t.Fatalf("create superadmin: %v", err)
-	}
-	if created.Status != StatusActive {
-		t.Fatalf("erwartet status active, hat %q", created.Status)
-	}
-
-	got, err := store.Get(ctx, created.ID)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if got.Email != "root@nexarch.internal" {
-		t.Fatalf("get email = %q", got.Email)
-	}
-
-	if _, err := store.Create(ctx, "root@nexarch.internal", "Root Zwei"); !errors.Is(err, ErrEmailTaken) {
-		t.Fatalf("erwartet ErrEmailTaken (globale eindeutigkeit), habe %v", err)
-	}
-
-	deactivated, err := store.Deactivate(ctx, created.ID)
-	if err != nil {
-		t.Fatalf("deactivate: %v", err)
-	}
-	if deactivated.Status != StatusInactive {
-		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
-	}
-}

internal/user/superadmin_store.go

@@ -1,77 +0,0 @@
-package user
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// SuperadminStore verwaltet mandantenuebergreifende Superadmin-Konten in der
-// Control-Plane-Registry (siehe internal/tenant.Registry). Superadmin-ohne-
-// Tenant ist dadurch ein eigener Typ statt eines Sonderfalls von User/
-// TenantUserStore — es gibt keinen Tenant-Parameter, den man weglassen
-// koennte (IAM-01, "ohne Sonderbehandlung im Code").
-type SuperadminStore struct {
-	pool *pgxpool.Pool
-}
-
-func NewSuperadminStore(pool *pgxpool.Pool) *SuperadminStore {
-	return &SuperadminStore{pool: pool}
-}
-
-func (s *SuperadminStore) Create(ctx context.Context, email, name string) (User, error) {
-	if err := ValidateEmail(email); err != nil {
-		return User{}, err
-	}
-
-	var u User
-	u.Email, u.Name, u.Status = email, name, StatusActive
-
-	row := s.pool.QueryRow(ctx, `
-		INSERT INTO superadmins (email, name, status)
-		VALUES ($1, $2, $3)
-		RETURNING id, created_at, updated_at
-	`, u.Email, u.Name, u.Status)
-
-	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
-		return User{}, mapWriteErr(err)
-	}
-	return u, nil
-}
-
-func (s *SuperadminStore) Get(ctx context.Context, id string) (User, error) {
-	return scanUser(s.pool.QueryRow(ctx, `
-		SELECT id, email, name, status, created_at, updated_at
-		FROM superadmins WHERE id = $1
-	`, id))
-}
-
-func (s *SuperadminStore) List(ctx context.Context) ([]User, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT id, email, name, status, created_at, updated_at
-		FROM superadmins ORDER BY created_at
-	`)
-	if err != nil {
-		return nil, fmt.Errorf("superadmins auflisten: %w", err)
-	}
-	defer rows.Close()
-
-	var out []User
-	for rows.Next() {
-		var u User
-		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
-			return nil, fmt.Errorf("superadmin lesen: %w", err)
-		}
-		out = append(out, u)
-	}
-	return out, rows.Err()
-}
-
-func (s *SuperadminStore) Deactivate(ctx context.Context, id string) (User, error) {
-	return scanUser(s.pool.QueryRow(ctx, `
-		UPDATE superadmins SET status = $2, updated_at = now()
-		WHERE id = $1
-		RETURNING id, email, name, status, created_at, updated_at
-	`, id, StatusInactive))
-}

internal/user/tenant_store.go

@@ -1,128 +0,0 @@
-package user
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgconn"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// TenantUserStore verwaltet Benutzer innerhalb GENAU EINER Tenant-Datenbank.
-// Welcher Mandant gemeint ist, ergibt sich ausschliesslich aus dem
-// uebergebenen Pool — es gibt keine tenant_id-Spalte (siehe migrations/tenant/0001_users.up.sql).
-type TenantUserStore struct {
-	pool *pgxpool.Pool
-}
-
-func NewTenantUserStore(pool *pgxpool.Pool) *TenantUserStore {
-	return &TenantUserStore{pool: pool}
-}
-
-func (s *TenantUserStore) Create(ctx context.Context, email, name string) (User, error) {
-	if err := ValidateEmail(email); err != nil {
-		return User{}, err
-	}
-
-	var u User
-	u.Email, u.Name, u.Status = email, name, StatusActive
-
-	row := s.pool.QueryRow(ctx, `
-		INSERT INTO users (email, name, status)
-		VALUES ($1, $2, $3)
-		RETURNING id, created_at, updated_at
-	`, u.Email, u.Name, u.Status)
-
-	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
-		return User{}, mapWriteErr(err)
-	}
-	return u, nil
-}
-
-func (s *TenantUserStore) Get(ctx context.Context, id string) (User, error) {
-	return scanUser(s.pool.QueryRow(ctx, `
-		SELECT id, email, name, status, created_at, updated_at
-		FROM users WHERE id = $1
-	`, id))
-}
-
-func (s *TenantUserStore) List(ctx context.Context) ([]User, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT id, email, name, status, created_at, updated_at
-		FROM users ORDER BY created_at
-	`)
-	if err != nil {
-		return nil, fmt.Errorf("benutzer auflisten: %w", err)
-	}
-	defer rows.Close()
-
-	var out []User
-	for rows.Next() {
-		var u User
-		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
-			return nil, fmt.Errorf("benutzer lesen: %w", err)
-		}
-		out = append(out, u)
-	}
-	return out, rows.Err()
-}
-
-// Update aendert Name und E-Mail. Eine leere email/name laesst das jeweilige
-// Feld unveraendert.
-func (s *TenantUserStore) Update(ctx context.Context, id, email, name string) (User, error) {
-	if email != "" {
-		if err := ValidateEmail(email); err != nil {
-			return User{}, err
-		}
-	}
-
-	row := s.pool.QueryRow(ctx, `
-		UPDATE users
-		SET email = COALESCE(NULLIF($2, ''), email),
-		    name = COALESCE(NULLIF($3, ''), name),
-		    updated_at = now()
-		WHERE id = $1
-		RETURNING id, email, name, status, created_at, updated_at
-	`, id, email, name)
-
-	u, err := scanUser(row)
-	if err != nil {
-		return User{}, mapWriteErr(err)
-	}
-	return u, nil
-}
-
-// Deactivate setzt den Benutzer auf inaktiv statt ihn zu loeschen.
-func (s *TenantUserStore) Deactivate(ctx context.Context, id string) (User, error) {
-	return scanUser(s.pool.QueryRow(ctx, `
-		UPDATE users SET status = $2, updated_at = now()
-		WHERE id = $1
-		RETURNING id, email, name, status, created_at, updated_at
-	`, id, StatusInactive))
-}
-
-func scanUser(row pgx.Row) (User, error) {
-	var u User
-	if err := row.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return User{}, ErrNotFound
-		}
-		return User{}, fmt.Errorf("benutzer lesen: %w", err)
-	}
-	return u, nil
-}
-
-// mapWriteErr uebersetzt den Unique-Constraint-Verstoss der E-Mail-Spalte in
-// einen sprechenden Fehler statt der rohen Postgres-Fehlermeldung.
-func mapWriteErr(err error) error {
-	var pgErr *pgconn.PgError
-	if errors.As(err, &pgErr) && pgErr.Code == "23505" {
-		return ErrEmailTaken
-	}
-	if errors.Is(err, pgx.ErrNoRows) {
-		return ErrNotFound
-	}
-	return fmt.Errorf("benutzer schreiben: %w", err)
-}

internal/user/user.go

@@ -1,42 +0,0 @@
-// Package user implementiert Core IAM-01: das Benutzer-Datenmodell und die
-// CRUD-Operationen. Tenant-Zugehoerigkeit ist ueber die Zieldatenbank
-// gegeben (Modell C, siehe internal/tenant) — Superadmin-Konten leben
-// dagegen mandantenuebergreifend in der Registry und sind ueber
-// SuperadminStore als eigener, First-Class-Typ modelliert, nicht als
-// tenant_id-NULL-Sonderfall in User.
-package user
-
-import (
-	"errors"
-	"regexp"
-	"time"
-)
-
-type Status string
-
-const (
-	StatusActive   Status = "active"
-	StatusInactive Status = "inactive"
-)
-
-type User struct {
-	ID        string
-	Email     string
-	Name      string
-	Status    Status
-	CreatedAt time.Time
-	UpdatedAt time.Time
-}
-
-var emailPattern = regexp.MustCompile(`^[^\s@]+@[^\s@]+\.[^\s@]+$`)
-
-var ErrInvalidEmail = errors.New("user: ungueltige E-Mail-Adresse")
-var ErrEmailTaken = errors.New("user: E-Mail-Adresse bereits vergeben")
-var ErrNotFound = errors.New("user: nicht gefunden")
-
-func ValidateEmail(email string) error {
-	if !emailPattern.MatchString(email) {
-		return ErrInvalidEmail
-	}
-	return nil
-}

internal/user/user_test.go

@@ -1,24 +0,0 @@
-package user
-
-import "testing"
-
-func TestValidateEmail(t *testing.T) {
-	cases := []struct {
-		email   string
-		wantErr bool
-	}{
-		{"a@b.de", false},
-		{"a.b+c@sub.example.com", false},
-		{"", true},
-		{"keine-email", true},
-		{"a@b", true},
-		{"@b.de", true},
-	}
-
-	for _, c := range cases {
-		err := ValidateEmail(c.email)
-		if (err != nil) != c.wantErr {
-			t.Errorf("ValidateEmail(%q) error = %v, wantErr %v", c.email, err, c.wantErr)
-		}
-	}
-}

migrations/0002_superadmins.down.sql

@@ -1 +0,0 @@
-DROP TABLE IF EXISTS superadmins;

migrations/0002_superadmins.up.sql

@@ -1,14 +0,0 @@
--- Superadmin-Konten arbeiten mandantenuebergreifend und leben deshalb in der
--- Control-Plane-Registry (siehe TEN-01), nicht in einer Tenant-Datenbank.
--- Das bildet "Superadmin ohne Tenant" strukturell als First-Class-Zustand ab,
--- statt ihn als Sonderfall in der Tenant-users-Tabelle zu behandeln
--- (IAM-01, siehe core-kanban/tickets/IAM-01.md — bekannte Fehler vermeiden).
--- E-Mail-Eindeutigkeit ist hier global, da die Registry-DB einmalig existiert.
-CREATE TABLE superadmins (
-    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    email        TEXT NOT NULL UNIQUE,
-    name         TEXT NOT NULL,
-    status       TEXT NOT NULL DEFAULT 'active',
-    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
-    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
-);

migrations/0003_policy_rules.down.sql

@@ -1,2 +0,0 @@
-DROP TABLE IF EXISTS policy_rule_changes;
-DROP TABLE IF EXISTS policy_rules;

migrations/0003_policy_rules.up.sql

@@ -1,24 +0,0 @@
--- Zentrale, deklarative Policy-Regeln (RBAC-02, siehe core-kanban/tickets/RBAC-02.md).
--- policy_rules haelt den AKTUELLEN, gewaehrten Regelsatz (Existenz = erlaubt,
--- Default-Deny fuer alles ohne Zeile). policy_rule_changes ist die
--- versionierte Aenderungshistorie (Akzeptanzkriterium 3: Regelwechsel ohne
--- Codeaenderung nachvollziehbar).
-CREATE TABLE policy_rules (
-    role       TEXT NOT NULL,
-    permission TEXT NOT NULL,
-    granted_by TEXT NOT NULL,
-    granted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-    PRIMARY KEY (role, permission)
-);
-
-CREATE TABLE policy_rule_changes (
-    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    role       TEXT NOT NULL,
-    permission TEXT NOT NULL,
-    action     TEXT NOT NULL CHECK (action IN ('grant', 'revoke')),
-    actor      TEXT NOT NULL,
-    version    INT NOT NULL,
-    changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-
-CREATE INDEX policy_rule_changes_idx ON policy_rule_changes (role, permission, version);

migrations/0004_audit_events.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS audit_events;

migrations/0004_audit_events.up.sql

@@ -0,0 +1,17 @@
+-- Zentrales Audit-Log-Modell (AUD-01, siehe core-kanban/tickets/AUD-01.md).
+-- Getrennt vom allgemeinen Anwendungs-Log (Akzeptanzkriterium 2): eigene
+-- Tabelle, eigenes Paket (internal/audit), kein Log-Framework.
+-- tenant_slug ist NOT NULL + darf nicht leer sein (Akzeptanzkriterium 2 /
+-- Pruefung 2) — mandantenuebergreifende Ereignisse nutzen den reservierten
+-- Wert 'system', niemals NULL oder leeren String.
+CREATE TABLE audit_events (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    occurred_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    tenant_slug  TEXT NOT NULL CHECK (tenant_slug <> ''),
+    actor        TEXT NOT NULL CHECK (actor <> ''),
+    action       TEXT NOT NULL CHECK (action <> ''),
+    target       TEXT NOT NULL,
+    metadata     JSONB NOT NULL DEFAULT '{}'::jsonb
+);
+
+CREATE INDEX audit_events_tenant_slug_idx ON audit_events (tenant_slug, occurred_at);

migrations/tenant/0001_users.down.sql

@@ -1 +0,0 @@
-DROP TABLE IF EXISTS users;

migrations/tenant/0001_users.up.sql

@@ -1,16 +0,0 @@
--- Benutzer-Datenmodell (IAM-01, siehe core-kanban/tickets/IAM-01.md).
--- Diese Migration laeuft in der DB EINES Mandanten (Modell C, siehe TEN-01) —
--- die Tenant-Zugehoerigkeit ist implizit durch die Datenbankverbindung
--- gegeben, es gibt daher bewusst KEINE tenant_id-Spalte.
--- E-Mail-Eindeutigkeit ist hier tenant-scoped: der UNIQUE-Constraint gilt
--- nur innerhalb dieser einen Tenant-Datenbank.
-CREATE EXTENSION IF NOT EXISTS pgcrypto;
-
-CREATE TABLE users (
-    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    email        TEXT NOT NULL UNIQUE,
-    name         TEXT NOT NULL,
-    status       TEXT NOT NULL DEFAULT 'active',
-    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
-    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
-);

migrations/tenant/0002_role_assignments.down.sql

@@ -1,2 +0,0 @@
-DROP TABLE IF EXISTS role_assignment_history;
-DROP TABLE IF EXISTS role_assignments;

migrations/tenant/0002_role_assignments.up.sql

@@ -1,23 +0,0 @@
--- Rollenzuweisung pro Benutzer (RBAC-01, siehe core-kanban/tickets/RBAC-01.md).
--- Nur 'user' und 'tenant_admin' sind hier zuweisbar — 'superadmin' lebt
--- mandantenuebergreifend in der Registry (IAM-01 SuperadminStore) und hat
--- daher bewusst KEINE Zeile in dieser tenant-lokalen Tabelle (Akzeptanz-
--- kriterium 1: nur Zuweisungen innerhalb der erlaubten Matrix).
-CREATE TABLE role_assignments (
-    user_id     UUID PRIMARY KEY REFERENCES users(id),
-    role        TEXT NOT NULL CHECK (role IN ('user', 'tenant_admin')),
-    granted_by  TEXT NOT NULL,
-    granted_at  TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-
--- Vollstaendige Historie jeder Rollenaenderung (Akzeptanzkriterium 3: wer
--- hat wann welche Rolle vergeben).
-CREATE TABLE role_assignment_history (
-    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    user_id     UUID NOT NULL,
-    role        TEXT NOT NULL,
-    granted_by  TEXT NOT NULL,
-    granted_at  TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-
-CREATE INDEX role_assignment_history_user_idx ON role_assignment_history (user_id, granted_at);

scripts/reset-test-env.sh

@@ -14,6 +14,7 @@ ROLE="nexarch_test"
 export PGPASSWORD="$PASS"
 
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;"
+psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS audit_events CASCADE;"
 
 dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
 for db in $dbs; do