CFG-03: benachrichtigungs-kanaele-e-mail-in-app

internal/channels: konkrete Zustellkanaele fuer CFG-02s Dispatcher.
TemplateStore.Resolve loest Vorlagen pro Tenant auf und faellt auf
GlobalTemplateScope zurueck, wenn ein Tenant keine eigene gesetzt hat
(Akzeptanzkriterium 3). Render nutzt text/template mit
Option("missingkey=error") — ein fehlender Platzhalter bricht das Rendering
MIT FEHLER ab, statt eine unvollstaendige Nachricht zu erzeugen
(Akzeptanzkriterium 1).

EmailSender implementiert notify.Sender: rendert ZUERST die Vorlage, bevor
ueberhaupt eine SMTP-Verbindung aufgebaut wird — schlaegt das Rendering
fehl, wird nie ein Netzwerkzugriff versucht. Ein anschliessend fehl-
schlagender SMTP-Versand liefert einen Fehler, den CFG-02s bereits
getestete Wiederholungslogik verarbeitet (kein zweiter Retry-Mechanismus
hier). InAppSender persistiert In-App-Nachrichten ueber InAppStore
(Akzeptanzkriterium 2, ueber API abrufbar/als gelesen markierbar). Router
waehlt den Kanal anhand Notification.Channel — ein neuer Kanal wird per
Register() ergaenzt, ohne Dispatcher oder Router umzubauen.

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Vorlagenrendering mit fehlenden Platzhaltern bricht kontrolliert ab —
   TestRender_MissingPlaceholderAborts und
   TestEmailSender_AbortsBeforeSMTPWhenTemplateMissing (Fehler kommt von der
   Vorlagenaufloesung, kein SMTP-Verbindungsversuch). PASS.
2. In-App-Benachrichtigung nach Markierung als gelesen korrekt gefuehrt —
   TestInAppStore_MarkReadIsReflectedCorrectly. PASS.
3. E-Mail-Versand bei nicht erreichbarem SMTP-Server loest dokumentiertes
   Retry-Verhalten ueber CFG-02 aus —
   TestEmailSender_TriggersDispatcherRetryOnUnreachableSMTP: echter
   EmailSender gegen unerreichbaren Host, ueber notify.Dispatcher
   eingereiht, nach ausgeschoepften Wiederholungen status=failed mit
   korrekter Versuchszahl. 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/cfgservice/service.go

@@ -0,0 +1,88 @@
+package cfgservice
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"time"
+)
+
+// DefaultCacheTTL ist die dokumentierte Cache-Invalidierungszeit
+// (Akzeptanzkriterium 2 / Pruefung 2 in diesem Ticket bezieht sich auf die
+// Aenderungsnachvollziehbarkeit — die Cache-Frist selbst folgt demselben
+// Muster wie internal/flag.DefaultCacheTTL).
+const DefaultCacheTTL = 5 * time.Second
+
+type cacheEntry struct {
+	value     Value
+	expiresAt time.Time
+}
+
+// Service ist die Leseseite mit Vorrangregel (Akzeptanzkriterium 1:
+// Tenant-Override vor Global-Default) und lokalem TTL-Cache.
+type Service struct {
+	store *Store
+	ttl   time.Duration
+
+	mu    sync.RWMutex
+	cache map[string]cacheEntry // Schluessel: key + "\x00" + tenantSlug
+}
+
+func NewService(store *Store, ttl time.Duration) *Service {
+	if ttl <= 0 {
+		ttl = DefaultCacheTTL
+	}
+	return &Service{store: store, ttl: ttl, cache: make(map[string]cacheEntry)}
+}
+
+func cacheKey(key, tenantSlug string) string {
+	return key + "\x00" + tenantSlug
+}
+
+// Resolve liefert den Konfigurationswert fuer einen Tenant: ein
+// Tenant-spezifischer Override hat Vorrang vor dem globalen Default
+// (Akzeptanzkriterium 1 / Pruefung 1). tenantSlug == "" wertet nur den
+// globalen Wert aus.
+func (s *Service) Resolve(ctx context.Context, tenantSlug, key string) (Value, error) {
+	ck := cacheKey(key, tenantSlug)
+
+	s.mu.RLock()
+	entry, exists := s.cache[ck]
+	fresh := exists && time.Now().Before(entry.expiresAt)
+	s.mu.RUnlock()
+	if fresh {
+		return entry.value, nil
+	}
+
+	v, err := s.resolveUncached(ctx, tenantSlug, key)
+	if err != nil {
+		return Value{}, err
+	}
+
+	s.mu.Lock()
+	s.cache[ck] = cacheEntry{value: v, expiresAt: time.Now().Add(s.ttl)}
+	s.mu.Unlock()
+	return v, nil
+}
+
+func (s *Service) resolveUncached(ctx context.Context, tenantSlug, key string) (Value, error) {
+	if tenantSlug != "" {
+		v, err := s.store.Get(ctx, key, tenantSlug)
+		if err == nil {
+			return v, nil
+		}
+		if !errors.Is(err, ErrNotFound) {
+			return Value{}, err
+		}
+	}
+	return s.store.Get(ctx, key, GlobalScope)
+}
+
+// Invalidate erzwingt beim naechsten Resolve-Aufruf ein sofortiges Neuladen
+// fuer einen bestimmten (key, tenantSlug) statt auf den TTL-Ablauf zu warten
+// — analog internal/flag.Service.Invalidate.
+func (s *Service) Invalidate(key, tenantSlug string) {
+	s.mu.Lock()
+	delete(s.cache, cacheKey(key, tenantSlug))
+	s.mu.Unlock()
+}

internal/cfgservice/service_test.go

@@ -0,0 +1,114 @@
+package cfgservice
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+// Akzeptanzkriterium 1 + Pruefung 1: Tenant-Override hat Vorrang vor
+// Global-Default, automatisiert getestet.
+func TestService_TenantOverrideTakesPrecedenceOverGlobal(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Set(ctx, "test_precedence_key", GlobalScope, "global-wert"); err != nil {
+		t.Fatalf("set global: %v", err)
+	}
+	if _, err := store.Set(ctx, "test_precedence_key", "test_acme", "tenant-wert"); err != nil {
+		t.Fatalf("set tenant: %v", err)
+	}
+
+	svc := NewService(store, time.Hour)
+
+	got, err := svc.Resolve(ctx, "test_acme", "test_precedence_key")
+	if err != nil {
+		t.Fatalf("resolve mit override: %v", err)
+	}
+	if got.Value != "tenant-wert" {
+		t.Fatalf("erwartet tenant-override, habe %q", got.Value)
+	}
+
+	gotOther, err := svc.Resolve(ctx, "test_anderer_tenant", "test_precedence_key")
+	if err != nil {
+		t.Fatalf("resolve ohne override: %v", err)
+	}
+	if gotOther.Value != "global-wert" {
+		t.Fatalf("erwartet global-default fuer tenant ohne override, habe %q", gotOther.Value)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Cache-Invalidierung nach
+// Konfigurationsaenderung innerhalb dokumentierter Zeit gemessen.
+func TestService_CacheInvalidationTiming(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	const ttl = 150 * time.Millisecond
+	if _, err := store.Set(ctx, "test_ttl_key", GlobalScope, "alt"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, ttl)
+
+	v, err := svc.Resolve(ctx, "", "test_ttl_key")
+	if err != nil {
+		t.Fatalf("resolve: %v", err)
+	}
+	if v.Value != "alt" {
+		t.Fatalf("erwartet 'alt', habe %q", v.Value)
+	}
+
+	changedAt := time.Now()
+	if _, err := store.Set(ctx, "test_ttl_key", GlobalScope, "neu"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+
+	v, err = svc.Resolve(ctx, "", "test_ttl_key")
+	if err != nil {
+		t.Fatalf("resolve direkt nach aenderung: %v", err)
+	}
+	if v.Value != "alt" {
+		t.Fatalf("cache haette den alten wert liefern sollen, habe %q", v.Value)
+	}
+
+	deadline := changedAt.Add(ttl + 100*time.Millisecond)
+	for time.Now().Before(deadline) {
+		v, err := svc.Resolve(ctx, "", "test_ttl_key")
+		if err != nil {
+			t.Fatalf("resolve: %v", err)
+		}
+		if v.Value == "neu" {
+			t.Logf("aenderung wurde nach %s wirksam (ziel: innerhalb %s + toleranz)", time.Since(changedAt), ttl)
+			return
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+	t.Fatalf("aenderung wurde nicht innerhalb von %s wirksam", deadline.Sub(changedAt))
+}
+
+func TestService_InvalidateForcesImmediateRefresh(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Set(ctx, "test_invalidate_key", GlobalScope, "alt"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, time.Hour)
+	_, _ = svc.Resolve(ctx, "", "test_invalidate_key")
+
+	if _, err := store.Set(ctx, "test_invalidate_key", GlobalScope, "neu"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc.Invalidate("test_invalidate_key", "")
+
+	v, err := svc.Resolve(ctx, "", "test_invalidate_key")
+	if err != nil {
+		t.Fatalf("resolve: %v", err)
+	}
+	if v.Value != "neu" {
+		t.Fatalf("erwartet sofort sichtbaren neuen wert nach Invalidate, habe %q", v.Value)
+	}
+}

internal/cfgservice/store.go

@@ -0,0 +1,129 @@
+// Package cfgservice implementiert Core CFG-01: den zentralen Dienst fuer
+// globale und tenant-spezifische Konfigurationswerte mit Versionierung und
+// Cache-Invalidierung. Andere Module lesen Konfiguration AUSSCHLIESSLICH
+// ueber dieses Paket (Akzeptanzkriterium 3), niemals ueber eigene Tabellen.
+package cfgservice
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// GlobalScope ist der reservierte Scope-Wert fuer globale Defaults — jeder
+// andere Scope-Wert ist ein Tenant-Slug (Akzeptanzkriterium 1).
+const GlobalScope = "global"
+
+var ErrNotFound = errors.New("cfgservice: kein wert fuer diesen key gefunden")
+
+type Value struct {
+	Key     string
+	Scope   string
+	Value   string
+	Version int
+}
+
+type HistoryEntry struct {
+	Key     string
+	Scope   string
+	Value   string
+	Version int
+}
+
+// Store ist die Schreib-/Verwaltungsseite. Set schreibt IMMER sowohl den
+// aktuellen Stand (config_values) als auch einen Historieneintrag
+// (config_value_history) in derselben Transaktion — eine Aenderung ohne
+// Versionshistorie ist strukturell ausgeschlossen (Akzeptanzkriterium 2).
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// Set schreibt einen neuen Wert fuer (key, scope) und erhoeht die Version um 1
+// (Version 1 bei erstmaligem Setzen).
+func (s *Store) Set(ctx context.Context, key, scope, value string) (Value, error) {
+	if scope == "" {
+		return Value{}, errors.New("cfgservice: scope darf nicht leer sein")
+	}
+
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return Value{}, fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	var currentVersion int
+	err = tx.QueryRow(ctx, `SELECT version FROM config_values WHERE key = $1 AND scope = $2`, key, scope).Scan(&currentVersion)
+	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
+		return Value{}, fmt.Errorf("aktuelle version lesen: %w", err)
+	}
+	newVersion := currentVersion + 1
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO config_values (key, scope, value, version, updated_at)
+		VALUES ($1, $2, $3, $4, now())
+		ON CONFLICT (key, scope) DO UPDATE SET value = $3, version = $4, updated_at = now()
+	`, key, scope, value, newVersion); err != nil {
+		return Value{}, fmt.Errorf("wert speichern: %w", err)
+	}
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO config_value_history (key, scope, value, version, changed_at)
+		VALUES ($1, $2, $3, $4, now())
+	`, key, scope, value, newVersion); err != nil {
+		return Value{}, fmt.Errorf("historie schreiben: %w", err)
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return Value{}, fmt.Errorf("transaktion committen: %w", err)
+	}
+
+	return Value{Key: key, Scope: scope, Value: value, Version: newVersion}, nil
+}
+
+// Get liefert den Wert fuer GENAU EINEN Scope (kein Vorrang-Fallback) — die
+// Vorrangregel (Tenant vor Global) lebt bewusst in Service.Resolve, damit
+// Store rein CRUD bleibt.
+func (s *Store) Get(ctx context.Context, key, scope string) (Value, error) {
+	var v Value
+	v.Key, v.Scope = key, scope
+	err := s.pool.QueryRow(ctx, `
+		SELECT value, version FROM config_values WHERE key = $1 AND scope = $2
+	`, key, scope).Scan(&v.Value, &v.Version)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Value{}, ErrNotFound
+		}
+		return Value{}, fmt.Errorf("wert lesen: %w", err)
+	}
+	return v, nil
+}
+
+// History liefert die vollstaendige Versionshistorie eines (key, scope) in
+// aufsteigender Reihenfolge (Akzeptanzkriterium 2 / Pruefung 3).
+func (s *Store) History(ctx context.Context, key, scope string) ([]HistoryEntry, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT key, scope, value, version FROM config_value_history
+		WHERE key = $1 AND scope = $2 ORDER BY version
+	`, key, scope)
+	if err != nil {
+		return nil, fmt.Errorf("historie abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []HistoryEntry
+	for rows.Next() {
+		var h HistoryEntry
+		if err := rows.Scan(&h.Key, &h.Scope, &h.Value, &h.Version); err != nil {
+			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
+		}
+		out = append(out, h)
+	}
+	return out, rows.Err()
+}

internal/cfgservice/store_test.go

@@ -0,0 +1,119 @@
+package cfgservice
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupStoreTest(t *testing.T) (*Store, 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 config_values (
+			key TEXT NOT NULL,
+			scope TEXT NOT NULL CHECK (scope <> ''),
+			value TEXT NOT NULL,
+			version INT NOT NULL,
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			PRIMARY KEY (key, scope)
+		);
+		CREATE TABLE IF NOT EXISTS config_value_history (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			key TEXT NOT NULL,
+			scope TEXT NOT NULL,
+			value TEXT NOT NULL,
+			version INT NOT NULL,
+			changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM config_value_history WHERE key LIKE 'test\_%' ESCAPE '\'`)
+		_, _ = pool.Exec(ctx, `DELETE FROM config_values WHERE key LIKE 'test\_%' ESCAPE '\'`)
+		pool.Close()
+	}
+	return NewStore(pool), cleanup
+}
+
+func TestStore_SetIncrementsVersion(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	v1, err := store.Set(ctx, "test_key", GlobalScope, "erster-wert")
+	if err != nil {
+		t.Fatalf("set 1: %v", err)
+	}
+	if v1.Version != 1 {
+		t.Fatalf("erwartet version 1, habe %d", v1.Version)
+	}
+
+	v2, err := store.Set(ctx, "test_key", GlobalScope, "zweiter-wert")
+	if err != nil {
+		t.Fatalf("set 2: %v", err)
+	}
+	if v2.Version != 2 {
+		t.Fatalf("erwartet version 2, habe %d", v2.Version)
+	}
+
+	got, err := store.Get(ctx, "test_key", GlobalScope)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Value != "zweiter-wert" || got.Version != 2 {
+		t.Fatalf("aktueller wert unerwartet: %+v", got)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 3: Versionierungshistorie ueber mehrere
+// Aenderungen hinweg nachvollzogen.
+func TestStore_HistoryTracksAllChanges(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	values := []string{"v1", "v2", "v3"}
+	for _, v := range values {
+		if _, err := store.Set(ctx, "test_history_key", GlobalScope, v); err != nil {
+			t.Fatalf("set %q: %v", v, err)
+		}
+	}
+
+	history, err := store.History(ctx, "test_history_key", GlobalScope)
+	if err != nil {
+		t.Fatalf("history: %v", err)
+	}
+	if len(history) != 3 {
+		t.Fatalf("erwartet 3 historieneintraege, habe %d", len(history))
+	}
+	for i, h := range history {
+		if h.Version != i+1 || h.Value != values[i] {
+			t.Fatalf("historieneintrag[%d] unerwartet: %+v", i, h)
+		}
+	}
+}
+
+func TestStore_GetUnknownKeyReturnsNotFound(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Get(ctx, "test_nie_gesetzt", GlobalScope); !errors.Is(err, ErrNotFound) {
+		t.Fatalf("erwartet ErrNotFound, habe %v", err)
+	}
+}

internal/channels/channels_test.go

@@ -0,0 +1,207 @@
+package channels
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+func setupTest(t *testing.T) (*TemplateStore, *InAppStore, 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 notification_templates (
+			tenant_slug TEXT NOT NULL, key TEXT NOT NULL, subject TEXT NOT NULL, body TEXT NOT NULL,
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (tenant_slug, key)
+		);
+		CREATE TABLE IF NOT EXISTS in_app_notifications (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), tenant_slug TEXT NOT NULL, user_id TEXT NOT NULL,
+			title TEXT NOT NULL, body TEXT NOT NULL, read_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS notification_jobs (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), channel TEXT NOT NULL, recipient TEXT NOT NULL,
+			payload JSONB NOT NULL DEFAULT '{}'::jsonb, status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','sent','failed')),
+			attempts INT NOT NULL DEFAULT 0, max_attempts INT NOT NULL DEFAULT 5,
+			next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(), last_error TEXT,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewTemplateStore(pool), NewInAppStore(pool), cleanup
+}
+
+func uniqueKey(prefix string) string {
+	return fmt.Sprintf("%s_%d", prefix, time.Now().UnixNano())
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: Vorlagenrendering mit fehlenden
+// Platzhaltern bricht kontrolliert ab.
+func TestRender_MissingPlaceholderAborts(t *testing.T) {
+	tmpl := Template{Subject: "Hallo {{.name}}", Body: "Dein Code: {{.code}}"}
+
+	_, _, err := Render(tmpl, map[string]any{"name": "Alice"}) // "code" fehlt
+	if err == nil {
+		t.Fatal("erwartet fehler bei fehlendem platzhalter 'code'")
+	}
+}
+
+func TestRender_SucceedsWithAllPlaceholders(t *testing.T) {
+	tmpl := Template{Subject: "Hallo {{.name}}", Body: "Dein Code: {{.code}}"}
+
+	subject, body, err := Render(tmpl, map[string]any{"name": "Alice", "code": "1234"})
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
+	if subject != "Hallo Alice" || body != "Dein Code: 1234" {
+		t.Fatalf("unerwartet: subject=%q body=%q", subject, body)
+	}
+}
+
+// Akzeptanzkriterium 3: Vorlagen pro Tenant anpassbar, Fallback auf global.
+func TestTemplateStore_TenantOverrideFallsBackToGlobal(t *testing.T) {
+	templates, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	key := uniqueKey("welcome")
+	if err := templates.Set(ctx, GlobalTemplateScope, key, "Willkommen", "Standardtext"); err != nil {
+		t.Fatalf("set global: %v", err)
+	}
+	if err := templates.Set(ctx, "acme", key, "Willkommen bei ACME", "ACME-Text"); err != nil {
+		t.Fatalf("set tenant: %v", err)
+	}
+
+	got, err := templates.Resolve(ctx, "acme", key)
+	if err != nil {
+		t.Fatalf("resolve acme: %v", err)
+	}
+	if got.Subject != "Willkommen bei ACME" {
+		t.Fatalf("erwartet tenant-vorlage, habe %q", got.Subject)
+	}
+
+	got, err = templates.Resolve(ctx, "globex", key) // hat keine eigene vorlage
+	if err != nil {
+		t.Fatalf("resolve globex: %v", err)
+	}
+	if got.Subject != "Willkommen" {
+		t.Fatalf("erwartet global-fallback, habe %q", got.Subject)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: als gelesen markiert wird korrekt gefuehrt.
+func TestInAppStore_MarkReadIsReflectedCorrectly(t *testing.T) {
+	_, inApp, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	userID := uniqueKey("user")
+	id, err := inApp.Create(ctx, "acme", userID, "Titel", "Text")
+	if err != nil {
+		t.Fatalf("create: %v", err)
+	}
+
+	list, err := inApp.ListForUser(ctx, "acme", userID)
+	if err != nil {
+		t.Fatalf("list (vor markierung): %v", err)
+	}
+	if len(list) != 1 || list[0].ReadAt != nil {
+		t.Fatalf("erwartet 1 ungelesene benachrichtigung, habe %+v", list)
+	}
+
+	if err := inApp.MarkRead(ctx, id); err != nil {
+		t.Fatalf("mark read: %v", err)
+	}
+
+	list, err = inApp.ListForUser(ctx, "acme", userID)
+	if err != nil {
+		t.Fatalf("list (nach markierung): %v", err)
+	}
+	if len(list) != 1 || list[0].ReadAt == nil {
+		t.Fatalf("erwartet als gelesen markiert, habe %+v", list)
+	}
+}
+
+// EmailSender bricht ab, BEVOR SMTP ueberhaupt kontaktiert wird, wenn keine
+// Vorlage aufloesbar ist — Nachweis, dass der Abbruch vor dem Netzwerkzugriff
+// erfolgt (Akzeptanzkriterium 1).
+func TestEmailSender_AbortsBeforeSMTPWhenTemplateMissing(t *testing.T) {
+	templates, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	sender := NewEmailSender(templates, "nicht-aufloesbarer-smtp-host.invalid", "25", "noreply@example.com")
+
+	err := sender.Send(ctx, notify.Notification{
+		Recipient: "user@example.com",
+		Payload:   map[string]any{"template_key": uniqueKey("nie_konfiguriert"), "tenant_slug": "acme"},
+	})
+	if !errors.Is(err, ErrTemplateNotFound) {
+		t.Fatalf("erwartet ErrTemplateNotFound (kein smtp-versuch), habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: E-Mail-Versand bei nicht erreichbarem
+// SMTP-Server loest das dokumentierte Retry-Verhalten ueber CFG-02 aus.
+func TestEmailSender_TriggersDispatcherRetryOnUnreachableSMTP(t *testing.T) {
+	templates, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	defer pool.Close()
+
+	key := uniqueKey("retry_test")
+	if err := templates.Set(ctx, GlobalTemplateScope, key, "Betreff", "Text ohne Platzhalter"); err != nil {
+		t.Fatalf("set template: %v", err)
+	}
+
+	sender := NewEmailSender(templates, "nicht-aufloesbarer-smtp-host.invalid", "25", "noreply@example.com")
+	dispatcher := notify.NewDispatcher(pool).WithRetryPolicy(2, time.Millisecond)
+
+	jobID, err := dispatcher.Enqueue(ctx, "email", "user@example.com", map[string]any{"template_key": key, "tenant_slug": "acme"})
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	for i := 0; i < 2; i++ {
+		time.Sleep(5 * time.Millisecond)
+		if _, _, err := dispatcher.ProcessDue(ctx, sender, 10); err != nil {
+			t.Fatalf("process due %d: %v", i, err)
+		}
+	}
+
+	var status string
+	var attempts int
+	if err := pool.QueryRow(ctx, `SELECT status, attempts FROM notification_jobs WHERE id = $1`, jobID).Scan(&status, &attempts); err != nil {
+		t.Fatalf("status lesen: %v", err)
+	}
+	if status != "failed" {
+		t.Fatalf("erwartet status failed nach ausgeschoepften wiederholungen bei unerreichbarem smtp, habe %q", status)
+	}
+	if attempts != 2 {
+		t.Fatalf("erwartet 2 versuche, habe %d", attempts)
+	}
+}

internal/channels/email.go

@@ -0,0 +1,81 @@
+package channels
+
+import (
+	"context"
+	"fmt"
+	"net/smtp"
+	"os"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+// EmailSender implementiert notify.Sender fuer den E-Mail-Kanal
+// (Akzeptanzkriterium 1). SMTP-Zugangsdaten kommen ausschliesslich aus
+// Umgebungsvariablen, nie aus Code/DB.
+type EmailSender struct {
+	templates *TemplateStore
+	host      string
+	port      string
+	from      string
+	username  string
+	password  string
+}
+
+// NewEmailSenderFromEnv liest NEXARCH_SMTP_HOST/PORT/FROM (Pflicht) sowie
+// optional NEXARCH_SMTP_USER/PASSWORD.
+func NewEmailSenderFromEnv(templates *TemplateStore) (*EmailSender, error) {
+	host := os.Getenv("NEXARCH_SMTP_HOST")
+	port := os.Getenv("NEXARCH_SMTP_PORT")
+	from := os.Getenv("NEXARCH_SMTP_FROM")
+	if host == "" || port == "" || from == "" {
+		return nil, fmt.Errorf("channels: NEXARCH_SMTP_HOST/PORT/FROM muessen gesetzt sein")
+	}
+	return &EmailSender{
+		templates: templates,
+		host:      host,
+		port:      port,
+		from:      from,
+		username:  os.Getenv("NEXARCH_SMTP_USER"),
+		password:  os.Getenv("NEXARCH_SMTP_PASSWORD"),
+	}, nil
+}
+
+// NewEmailSender erlaubt Tests, Host/Port explizit zu setzen (z.B. einen
+// absichtlich nicht erreichbaren Host fuer den Retry-Nachweis), ohne
+// Umgebungsvariablen zu benoetigen.
+func NewEmailSender(templates *TemplateStore, host, port, from string) *EmailSender {
+	return &EmailSender{templates: templates, host: host, port: port, from: from}
+}
+
+// Send rendert zuerst die Vorlage — schlaegt das fehl (z.B. fehlender
+// Platzhalter), wird NIE eine SMTP-Verbindung aufgebaut
+// (Akzeptanzkriterium 1 / Pruefung 1: kontrollierter Abbruch statt
+// fehlerhafter Mail). Ein danach fehlschlagender SMTP-Versand liefert einen
+// Fehler zurueck, den CFG-02s Dispatcher fuer die bereits getestete
+// Wiederholungslogik nutzt (Akzeptanzkriterium 3 / Pruefung 3) — kein
+// zweiter Retry-Mechanismus hier.
+func (e *EmailSender) Send(ctx context.Context, n notify.Notification) error {
+	templateKey, _ := n.Payload["template_key"].(string)
+	tenantSlug, _ := n.Payload["tenant_slug"].(string)
+
+	tmpl, err := e.templates.Resolve(ctx, tenantSlug, templateKey)
+	if err != nil {
+		return fmt.Errorf("vorlage aufloesen: %w", err)
+	}
+	subject, body, err := Render(tmpl, n.Payload)
+	if err != nil {
+		return err
+	}
+
+	msg := []byte("Subject: " + subject + "\r\n\r\n" + body)
+
+	var auth smtp.Auth
+	if e.username != "" {
+		auth = smtp.PlainAuth("", e.username, e.password, e.host)
+	}
+	addr := e.host + ":" + e.port
+	if err := smtp.SendMail(addr, auth, e.from, []string{n.Recipient}, msg); err != nil {
+		return fmt.Errorf("smtp-versand fehlgeschlagen: %w", err)
+	}
+	return nil
+}

internal/channels/inapp.go

@@ -0,0 +1,74 @@
+package channels
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+type InAppNotification struct {
+	ID         string
+	TenantSlug string
+	UserID     string
+	Title      string
+	Body       string
+	ReadAt     *time.Time
+	CreatedAt  time.Time
+}
+
+// InAppStore persistiert In-App-Benachrichtigungen (Akzeptanzkriterium 2).
+type InAppStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewInAppStore(pool *pgxpool.Pool) *InAppStore {
+	return &InAppStore{pool: pool}
+}
+
+func (s *InAppStore) Create(ctx context.Context, tenantSlug, userID, title, body string) (string, error) {
+	var id string
+	err := s.pool.QueryRow(ctx, `
+		INSERT INTO in_app_notifications (tenant_slug, user_id, title, body)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id
+	`, tenantSlug, userID, title, body).Scan(&id)
+	if err != nil {
+		return "", fmt.Errorf("in-app-benachrichtigung speichern: %w", err)
+	}
+	return id, nil
+}
+
+// ListForUser liefert alle Benachrichtigungen eines Benutzers (ueber API
+// abrufbar, Akzeptanzkriterium 2).
+func (s *InAppStore) ListForUser(ctx context.Context, tenantSlug, userID string) ([]InAppNotification, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT id, title, body, read_at, created_at FROM in_app_notifications
+		WHERE tenant_slug = $1 AND user_id = $2 ORDER BY created_at DESC
+	`, tenantSlug, userID)
+	if err != nil {
+		return nil, fmt.Errorf("benachrichtigungen auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []InAppNotification
+	for rows.Next() {
+		n := InAppNotification{TenantSlug: tenantSlug, UserID: userID}
+		if err := rows.Scan(&n.ID, &n.Title, &n.Body, &n.ReadAt, &n.CreatedAt); err != nil {
+			return nil, fmt.Errorf("benachrichtigung lesen: %w", err)
+		}
+		out = append(out, n)
+	}
+	return out, rows.Err()
+}
+
+// MarkRead markiert eine Benachrichtigung als gelesen (Akzeptanzkriterium 2
+// / Pruefung 2).
+func (s *InAppStore) MarkRead(ctx context.Context, id string) error {
+	_, err := s.pool.Exec(ctx, `UPDATE in_app_notifications SET read_at = now() WHERE id = $1`, id)
+	if err != nil {
+		return fmt.Errorf("als gelesen markieren: %w", err)
+	}
+	return nil
+}

internal/channels/inapp_sender.go

@@ -0,0 +1,41 @@
+package channels
+
+import (
+	"context"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+// InAppSender implementiert notify.Sender fuer den In-App-Kanal
+// (Akzeptanzkriterium 2). Nutzt eine Vorlage, falls payload["template_key"]
+// gesetzt ist, sonst direkt payload["title"]/["body"].
+type InAppSender struct {
+	store     *InAppStore
+	templates *TemplateStore
+}
+
+func NewInAppSender(store *InAppStore, templates *TemplateStore) *InAppSender {
+	return &InAppSender{store: store, templates: templates}
+}
+
+func (s *InAppSender) Send(ctx context.Context, n notify.Notification) error {
+	tenantSlug, _ := n.Payload["tenant_slug"].(string)
+
+	var title, body string
+	if templateKey, ok := n.Payload["template_key"].(string); ok && templateKey != "" {
+		tmpl, err := s.templates.Resolve(ctx, tenantSlug, templateKey)
+		if err != nil {
+			return err
+		}
+		title, body, err = Render(tmpl, n.Payload)
+		if err != nil {
+			return err
+		}
+	} else {
+		title, _ = n.Payload["title"].(string)
+		body, _ = n.Payload["body"].(string)
+	}
+
+	_, err := s.store.Create(ctx, tenantSlug, n.Recipient, title, body)
+	return err
+}

internal/channels/router.go

@@ -0,0 +1,32 @@
+package channels
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+// Router waehlt anhand von Notification.Channel den zustaendigen Kanal aus
+// — ein neuer Kanal wird per Register() ergaenzt, ohne den Dispatcher
+// (CFG-02) oder Router selbst umzubauen (Unleash-artiger Strategie-Gedanke,
+// siehe Ticket-DNA).
+type Router struct {
+	channels map[string]notify.Sender
+}
+
+func NewRouter() *Router {
+	return &Router{channels: make(map[string]notify.Sender)}
+}
+
+func (r *Router) Register(channel string, sender notify.Sender) {
+	r.channels[channel] = sender
+}
+
+func (r *Router) Send(ctx context.Context, n notify.Notification) error {
+	sender, ok := r.channels[n.Channel]
+	if !ok {
+		return fmt.Errorf("channels: unbekannter kanal %q", n.Channel)
+	}
+	return sender.Send(ctx, n)
+}

internal/channels/template.go

@@ -0,0 +1,104 @@
+// Package channels implementiert Core CFG-03: konkrete Zustellkanaele fuer
+// den CFG-02-Dispatcher (E-Mail, In-App) inklusive Vorlagenverwaltung.
+// Neue Kanaele lassen sich ergaenzen, ohne den Dispatcher selbst
+// anzufassen — jeder Kanal implementiert nur notify.Sender.
+package channels
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"text/template"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// GlobalTemplateScope ist der Fallback-Wert, wenn ein Tenant keine eigene
+// Vorlage konfiguriert hat (Akzeptanzkriterium 3).
+const GlobalTemplateScope = "global"
+
+var ErrTemplateNotFound = errors.New("channels: keine vorlage gefunden")
+
+type Template struct {
+	Subject string
+	Body    string
+}
+
+type TemplateStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewTemplateStore(pool *pgxpool.Pool) *TemplateStore {
+	return &TemplateStore{pool: pool}
+}
+
+// Set legt eine Vorlage fuer einen Tenant (oder GlobalTemplateScope) fest.
+func (s *TemplateStore) Set(ctx context.Context, tenantSlug, key, subject, body string) error {
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO notification_templates (tenant_slug, key, subject, body, updated_at)
+		VALUES ($1, $2, $3, $4, now())
+		ON CONFLICT (tenant_slug, key) DO UPDATE SET subject = $3, body = $4, updated_at = now()
+	`, tenantSlug, key, subject, body)
+	if err != nil {
+		return fmt.Errorf("vorlage speichern: %w", err)
+	}
+	return nil
+}
+
+// Resolve liefert die Vorlage eines Tenants, faellt auf GlobalTemplateScope
+// zurueck, wenn der Tenant keine eigene gesetzt hat (Akzeptanzkriterium 3).
+func (s *TemplateStore) Resolve(ctx context.Context, tenantSlug, key string) (Template, error) {
+	if tenantSlug != "" && tenantSlug != GlobalTemplateScope {
+		if t, err := s.get(ctx, tenantSlug, key); err == nil {
+			return t, nil
+		} else if !errors.Is(err, ErrTemplateNotFound) {
+			return Template{}, err
+		}
+	}
+	return s.get(ctx, GlobalTemplateScope, key)
+}
+
+func (s *TemplateStore) get(ctx context.Context, tenantSlug, key string) (Template, error) {
+	var t Template
+	err := s.pool.QueryRow(ctx, `
+		SELECT subject, body FROM notification_templates WHERE tenant_slug = $1 AND key = $2
+	`, tenantSlug, key).Scan(&t.Subject, &t.Body)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Template{}, ErrTemplateNotFound
+		}
+		return Template{}, fmt.Errorf("vorlage lesen: %w", err)
+	}
+	return t, nil
+}
+
+// Render fuellt eine Vorlage mit data. Fehlt ein referenzierter Platzhalter
+// in data, bricht das Rendering kontrolliert MIT FEHLER ab, statt eine
+// fehlerhafte/unvollstaendige Nachricht zu erzeugen (Akzeptanzkriterium 1 /
+// Pruefung 1) — text/template mit Option("missingkey=error") liefert dafuer
+// einen Fehler statt stillschweigend "<no value>" einzusetzen.
+func Render(tmpl Template, data map[string]any) (subject, body string, err error) {
+	subject, err = renderOne("subject", tmpl.Subject, data)
+	if err != nil {
+		return "", "", err
+	}
+	body, err = renderOne("body", tmpl.Body, data)
+	if err != nil {
+		return "", "", err
+	}
+	return subject, body, nil
+}
+
+func renderOne(name, text string, data map[string]any) (string, error) {
+	tmpl, err := template.New(name).Option("missingkey=error").Parse(text)
+	if err != nil {
+		return "", fmt.Errorf("vorlage %q parsen: %w", name, err)
+	}
+	var buf bytes.Buffer
+	if err := tmpl.Execute(&buf, data); err != nil {
+		return "", fmt.Errorf("vorlage %q rendern (fehlender platzhalter?): %w", name, err)
+	}
+	return buf.String(), nil
+}

internal/notify/dispatcher.go

@@ -0,0 +1,81 @@
+// Package notify implementiert Core CFG-02: den zentralen Benachrichtigungs-
+// Dispatcher, ueber den beliebige Module Benachrichtigungen ausloesen —
+// Warteschlange, Wiederholungslogik, Kanal-Abstraktion. Die tatsaechlichen
+// Kanaele (E-Mail/In-App) sind CFG-03, hier gibt es nur die Sender-
+// Schnittstelle als Vorbereitung.
+package notify
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// DefaultMaxAttempts begrenzt Wiederholungsversuche (Akzeptanzkriterium 2) —
+// nach dieser Anzahl gibt der Dispatcher kontrolliert auf (status=failed)
+// statt endlos zu wiederholen.
+const DefaultMaxAttempts = 5
+
+// DefaultRetryBackoff ist die Basis-Wartezeit zwischen Wiederholungen,
+// linear mit der Versuchsnummer skaliert.
+const DefaultRetryBackoff = 200 * time.Millisecond
+
+type Notification struct {
+	ID        string
+	Channel   string
+	Recipient string
+	Payload   map[string]any
+	Attempts  int
+}
+
+// Sender ist die schmale Schnittstelle, die ein konkreter Kanal (CFG-03)
+// implementiert. Der Dispatcher selbst weiss nichts ueber E-Mail/In-App.
+type Sender interface {
+	Send(ctx context.Context, n Notification) error
+}
+
+// Dispatcher ist die EINE Schnittstelle, ueber die Module Benachrichtigungen
+// ausloesen — kein Modul baut eigenen Versandcode (Akzeptanzkriterium 1).
+type Dispatcher struct {
+	pool         *pgxpool.Pool
+	maxAttempts  int
+	retryBackoff time.Duration
+}
+
+func NewDispatcher(pool *pgxpool.Pool) *Dispatcher {
+	return &Dispatcher{pool: pool, maxAttempts: DefaultMaxAttempts, retryBackoff: DefaultRetryBackoff}
+}
+
+// WithRetryPolicy erlaubt Tests/Betrieb, Versuchsanzahl und Backoff
+// anzupassen, ohne die Default-Policy im Produktionscode zu veraendern.
+func (d *Dispatcher) WithRetryPolicy(maxAttempts int, backoff time.Duration) *Dispatcher {
+	return &Dispatcher{pool: d.pool, maxAttempts: maxAttempts, retryBackoff: backoff}
+}
+
+// Enqueue reiht eine Benachrichtigung in die Postgres-Warteschlange ein und
+// kehrt sofort zurueck — die Zeile ueberlebt jeden Neustart des Dispatcher-
+// Prozesses unveraendert (Akzeptanzkriterium 3), da sie ausschliesslich in
+// der Datenbank existiert, nicht im Prozessspeicher.
+func (d *Dispatcher) Enqueue(ctx context.Context, channel, recipient string, payload map[string]any) (string, error) {
+	if payload == nil {
+		payload = map[string]any{}
+	}
+	payloadJSON, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("payload serialisieren: %w", err)
+	}
+
+	var id string
+	err = d.pool.QueryRow(ctx, `
+		INSERT INTO notification_jobs (channel, recipient, payload, max_attempts)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id
+	`, channel, recipient, payloadJSON, d.maxAttempts).Scan(&id)
+	if err != nil {
+		return "", fmt.Errorf("benachrichtigung einreihen: %w", err)
+	}
+	return id, nil
+}

internal/notify/dispatcher_test.go

@@ -0,0 +1,219 @@
+package notify
+
+import (
+	"context"
+	"errors"
+	"os"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupTest(t *testing.T) (*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 notification_jobs (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			channel TEXT NOT NULL,
+			recipient TEXT NOT NULL,
+			payload JSONB NOT NULL DEFAULT '{}'::jsonb,
+			status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),
+			attempts INT NOT NULL DEFAULT 0,
+			max_attempts INT NOT NULL DEFAULT 5,
+			next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			last_error TEXT,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return pool, cleanup
+}
+
+type fakeSender struct {
+	mu        sync.Mutex
+	sentIDs   []string
+	failUntil int
+	calls     int
+}
+
+func (f *fakeSender) Send(ctx context.Context, n Notification) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.calls++
+	if f.calls <= f.failUntil {
+		return errors.New("simulierter zustellfehler")
+	}
+	f.sentIDs = append(f.sentIDs, n.ID)
+	return nil
+}
+
+func (f *fakeSender) sentCount() int {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return len(f.sentIDs)
+}
+
+// Akzeptanzkriterium 1: Module loesen ueber Enqueue aus, keine eigene
+// Versandlogik noetig.
+func TestDispatcher_EnqueueAndProcess(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool)
+	id, err := d.Enqueue(ctx, "email", "alice@example.com", map[string]any{"subject": "Willkommen"})
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+	if id == "" {
+		t.Fatal("erwartet nicht-leere id")
+	}
+
+	sender := &fakeSender{}
+	sent, failed, err := d.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process: %v", err)
+	}
+	if sent != 1 || failed != 0 {
+		t.Fatalf("erwartet sent=1 failed=0, habe sent=%d failed=%d", sent, failed)
+	}
+	if sender.sentCount() != 1 {
+		t.Fatalf("erwartet 1 zustellung, habe %d", sender.sentCount())
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Wiederholungslogik greift bei
+// simuliertem Fehler und bricht nach definierter Anzahl kontrolliert ab.
+func TestProcessDue_RetriesThenGivesUpAfterMaxAttempts(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool).WithRetryPolicy(3, time.Millisecond)
+	id, err := d.Enqueue(ctx, "email", "bob@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	sender := &fakeSender{failUntil: 100} // schlaegt bei jedem versuch fehl
+
+	for i := 0; i < 3; i++ {
+		time.Sleep(5 * time.Millisecond) // next_attempt_at abwarten
+		if _, _, err := d.ProcessDue(ctx, sender, 10); err != nil {
+			t.Fatalf("process %d: %v", i, err)
+		}
+	}
+
+	var status string
+	var attempts int
+	if err := pool.QueryRow(ctx, `SELECT status, attempts FROM notification_jobs WHERE id = $1`, id).Scan(&status, &attempts); err != nil {
+		t.Fatalf("status lesen: %v", err)
+	}
+	if status != "failed" {
+		t.Fatalf("erwartet status failed nach max_attempts, habe %q", status)
+	}
+	if attempts != 3 {
+		t.Fatalf("erwartet 3 versuche, habe %d", attempts)
+	}
+
+	// Weiteres ProcessDue darf den bereits aufgegebenen job nicht mehr anfassen.
+	sent, failed, err := d.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process nach abbruch: %v", err)
+	}
+	if sent != 0 || failed != 0 {
+		t.Fatalf("erwartet keine weitere verarbeitung, habe sent=%d failed=%d", sent, failed)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 1: Neustart des Dienstes waehrend offener
+// Zustellung verliert keine Nachricht — simuliert durch eine komplett neue
+// Dispatcher/Pool-Instanz nach dem Enqueue, bevor irgendetwas verarbeitet wurde.
+func TestQueue_SurvivesRestartWithoutMessageLoss(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	firstInstance := NewDispatcher(pool)
+	id, err := firstInstance.Enqueue(ctx, "email", "carol@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	// "Neustart": eine voellig neue Dispatcher-Instanz (repraesentiert einen
+	// neuen Prozess) verbindet sich neu und verarbeitet die Warteschlange —
+	// die Nachricht existiert ausschliesslich in Postgres, nicht im
+	// Prozessspeicher der ersten Instanz.
+	restartedInstance := NewDispatcher(pool)
+	sender := &fakeSender{}
+	sent, failed, err := restartedInstance.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process nach neustart: %v", err)
+	}
+	if sent != 1 || failed != 0 {
+		t.Fatalf("erwartet sent=1 nach neustart, habe sent=%d failed=%d", sent, failed)
+	}
+	if len(sender.sentIDs) != 1 || sender.sentIDs[0] != id {
+		t.Fatalf("erwartet zustellung der urspruenglichen nachricht %q, habe %v", id, sender.sentIDs)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: zwei gleichzeitig ausloesende Module,
+// beide Nachrichten werden korrekt (und nicht doppelt) zugestellt.
+func TestProcessDue_ConcurrentDispatchBothDelivered(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool)
+	idA, err := d.Enqueue(ctx, "email", "modul-a@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue a: %v", err)
+	}
+	idB, err := d.Enqueue(ctx, "email", "modul-b@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue b: %v", err)
+	}
+
+	sender := &fakeSender{}
+	var wg sync.WaitGroup
+	for i := 0; i < 2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if _, _, err := d.ProcessDue(ctx, sender, 10); err != nil {
+				t.Errorf("process: %v", err)
+			}
+		}()
+	}
+	wg.Wait()
+
+	if sender.sentCount() != 2 {
+		t.Fatalf("erwartet genau 2 zustellungen, habe %d: %v", sender.sentCount(), sender.sentIDs)
+	}
+	seen := map[string]bool{}
+	for _, id := range sender.sentIDs {
+		if seen[id] {
+			t.Fatalf("nachricht %q wurde doppelt zugestellt", id)
+		}
+		seen[id] = true
+	}
+	if !seen[idA] || !seen[idB] {
+		t.Fatalf("erwartet beide nachrichten zugestellt, habe %v", sender.sentIDs)
+	}
+}

internal/notify/worker.go

@@ -0,0 +1,102 @@
+package notify
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// ProcessDue holt bis zu limit faellige Benachrichtigungen und versucht sie
+// ueber sender zuzustellen. FOR UPDATE SKIP LOCKED serialisiert konkurrierende
+// Aufrufe (Akzeptanzkriterium 3 / Pruefung 3: zwei gleichzeitig ausloesende
+// Module duerfen sich nicht gegenseitig blockieren oder Nachrichten doppelt
+// zustellen) — dieselbe Konvention wie internal/tenant.Lifecycle.ProcessDueDeletions.
+func (d *Dispatcher) ProcessDue(ctx context.Context, sender Sender, limit int) (sent, failed int, err error) {
+	tx, err := d.pool.Begin(ctx)
+	if err != nil {
+		return 0, 0, fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	rows, err := tx.Query(ctx, `
+		SELECT id, channel, recipient, payload, attempts, max_attempts
+		FROM notification_jobs
+		WHERE status = 'pending' AND next_attempt_at <= now()
+		ORDER BY created_at
+		FOR UPDATE SKIP LOCKED
+		LIMIT $1
+	`, limit)
+	if err != nil {
+		return 0, 0, fmt.Errorf("faellige benachrichtigungen abfragen: %w", err)
+	}
+
+	type due struct {
+		id, channel, recipient string
+		payload                []byte
+		attempts, maxAttempts  int
+	}
+	var candidates []due
+	for rows.Next() {
+		var c due
+		if err := rows.Scan(&c.id, &c.channel, &c.recipient, &c.payload, &c.attempts, &c.maxAttempts); err != nil {
+			rows.Close()
+			return 0, 0, fmt.Errorf("faellige benachrichtigung lesen: %w", err)
+		}
+		candidates = append(candidates, c)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return 0, 0, err
+	}
+
+	for _, c := range candidates {
+		var payload map[string]any
+		if err := json.Unmarshal(c.payload, &payload); err != nil {
+			payload = map[string]any{}
+		}
+
+		sendErr := sender.Send(ctx, Notification{
+			ID: c.id, Channel: c.channel, Recipient: c.recipient, Payload: payload, Attempts: c.attempts,
+		})
+
+		if sendErr == nil {
+			if _, err := tx.Exec(ctx, `
+				UPDATE notification_jobs SET status = 'sent', updated_at = now() WHERE id = $1
+			`, c.id); err != nil {
+				return sent, failed, fmt.Errorf("erfolg speichern: %w", err)
+			}
+			sent++
+			continue
+		}
+
+		newAttempts := c.attempts + 1
+		if newAttempts >= c.maxAttempts {
+			// Akzeptanzkriterium 2: kontrollierter Abbruch nach definierter
+			// Anzahl Versuche, kein endloses Wiederholen.
+			if _, err := tx.Exec(ctx, `
+				UPDATE notification_jobs
+				SET status = 'failed', attempts = $2, last_error = $3, updated_at = now()
+				WHERE id = $1
+			`, c.id, newAttempts, sendErr.Error()); err != nil {
+				return sent, failed, fmt.Errorf("fehlschlag speichern: %w", err)
+			}
+			failed++
+			continue
+		}
+
+		nextAttempt := time.Now().Add(time.Duration(newAttempts) * d.retryBackoff)
+		if _, err := tx.Exec(ctx, `
+			UPDATE notification_jobs
+			SET attempts = $2, next_attempt_at = $3, last_error = $4, updated_at = now()
+			WHERE id = $1
+		`, c.id, newAttempts, nextAttempt, sendErr.Error()); err != nil {
+			return sent, failed, fmt.Errorf("wiederholung planen: %w", err)
+		}
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return 0, 0, fmt.Errorf("transaktion committen: %w", err)
+	}
+	return sent, failed, nil
+}

internal/rbac/group.go

@@ -1,159 +0,0 @@
-package rbac
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var ErrGroupNotFound = errors.New("rbac: gruppe nicht gefunden")
-
-type Group struct {
-	ID   string
-	Name string
-	Role Role // leer, wenn der Gruppe noch keine Rolle zugewiesen wurde
-}
-
-// GroupStore verwaltet Gruppen/Abteilungen innerhalb GENAU EINER Tenant-
-// Datenbank (Modell C, wie Store fuer direkte Rollenzuweisungen) —
-// Akzeptanzkriterium 3 (tenant-isoliert) ist damit strukturell erfuellt.
-type GroupStore struct {
-	pool *pgxpool.Pool
-}
-
-func NewGroupStore(pool *pgxpool.Pool) *GroupStore {
-	return &GroupStore{pool: pool}
-}
-
-// CreateGroup legt eine neue, noch rollenlose Gruppe an (Akzeptanzkriterium 1).
-func (s *GroupStore) CreateGroup(ctx context.Context, name string) (Group, error) {
-	if name == "" {
-		return Group{}, errors.New("rbac: gruppenname darf nicht leer sein")
-	}
-	var g Group
-	g.Name = name
-	if err := s.pool.QueryRow(ctx, `
-		INSERT INTO groups (name) VALUES ($1) RETURNING id
-	`, name).Scan(&g.ID); err != nil {
-		return Group{}, fmt.Errorf("gruppe anlegen: %w", err)
-	}
-	return g, nil
-}
-
-// SetGroupRole weist der Gruppe eine Rolle zu (Akzeptanzkriterium 2) — nur
-// 'user'/'tenant_admin' sind auf Gruppenebene zuweisbar, dieselbe erlaubte
-// Matrix wie in Store.Assign (superadmin bleibt mandantenuebergreifend und
-// ausserhalb jeder Gruppenlogik).
-func (s *GroupStore) SetGroupRole(ctx context.Context, groupID string, role Role) error {
-	if !assignableRoles[role] {
-		return ErrRoleNotAssignableInTenantScope
-	}
-	tag, err := s.pool.Exec(ctx, `UPDATE groups SET role = $2 WHERE id = $1`, groupID, string(role))
-	if err != nil {
-		return fmt.Errorf("gruppenrolle setzen: %w", err)
-	}
-	if tag.RowsAffected() == 0 {
-		return ErrGroupNotFound
-	}
-	return nil
-}
-
-// AddMember nimmt einen Benutzer in die Gruppe auf.
-func (s *GroupStore) AddMember(ctx context.Context, groupID, userID string) error {
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO group_members (group_id, user_id) VALUES ($1, $2)
-		ON CONFLICT (group_id, user_id) DO NOTHING
-	`, groupID, userID)
-	if err != nil {
-		return fmt.Errorf("mitglied hinzufuegen: %w", err)
-	}
-	return nil
-}
-
-// RemoveMember entfernt einen Benutzer aus der Gruppe — die gruppenbasierten
-// Rechte entfallen fuer ihn sofort (Akzeptanzkriterium 3 / Pruefung 2), da
-// EffectivePermissionsForUser bei jedem Aufruf neu berechnet wird, nicht
-// zwischengespeichert.
-func (s *GroupStore) RemoveMember(ctx context.Context, groupID, userID string) error {
-	_, err := s.pool.Exec(ctx, `DELETE FROM group_members WHERE group_id = $1 AND user_id = $2`, groupID, userID)
-	if err != nil {
-		return fmt.Errorf("mitglied entfernen: %w", err)
-	}
-	return nil
-}
-
-// DeleteGroup loescht die Gruppe — ON DELETE CASCADE entfernt die
-// Mitgliedschaften mit, Benutzerkonten selbst bleiben unberuehrt
-// (Akzeptanzkriterium 3).
-func (s *GroupStore) DeleteGroup(ctx context.Context, groupID string) error {
-	_, err := s.pool.Exec(ctx, `DELETE FROM groups WHERE id = $1`, groupID)
-	if err != nil {
-		return fmt.Errorf("gruppe loeschen: %w", err)
-	}
-	return nil
-}
-
-// RolesForUser liefert alle Rollen, die einem Benutzer ueber seine
-// Gruppenmitgliedschaften zufallen (Akzeptanzkriterium 2: wirkt auf alle
-// Mitglieder). Eine Gruppe ohne zugewiesene Rolle traegt nichts bei.
-func (s *GroupStore) RolesForUser(ctx context.Context, userID string) ([]Role, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT g.role FROM groups g
-		JOIN group_members gm ON gm.group_id = g.id
-		WHERE gm.user_id = $1 AND g.role IS NOT NULL
-	`, userID)
-	if err != nil {
-		return nil, fmt.Errorf("gruppenrollen abfragen: %w", err)
-	}
-	defer rows.Close()
-
-	var out []Role
-	for rows.Next() {
-		var r string
-		if err := rows.Scan(&r); err != nil {
-			return nil, fmt.Errorf("gruppenrolle lesen: %w", err)
-		}
-		out = append(out, Role(r))
-	}
-	return out, rows.Err()
-}
-
-// EffectivePermissionsForUser vereinigt die Rechte aus der direkten
-// Rollenzuweisung (Store, RBAC-01) mit allen Rechten aus Gruppenrollen —
-// jede einzelne Rolle wird ueber die bestehende Hierarchie (EffectivePermissions)
-// aufgeloest, das Ergebnis dedupliziert.
-func (s *GroupStore) EffectivePermissionsForUser(ctx context.Context, directStore *Store, userID string) ([]Permission, error) {
-	seen := make(map[Permission]bool)
-	var out []Permission
-
-	add := func(role Role) {
-		for _, p := range EffectivePermissions(role) {
-			if !seen[p] {
-				seen[p] = true
-				out = append(out, p)
-			}
-		}
-	}
-
-	if directStore != nil {
-		assignment, err := directStore.Get(ctx, userID)
-		if err != nil && !errors.Is(err, ErrNotFound) {
-			return nil, err
-		}
-		if err == nil {
-			add(assignment.Role)
-		}
-	}
-
-	groupRoles, err := s.RolesForUser(ctx, userID)
-	if err != nil {
-		return nil, err
-	}
-	for _, r := range groupRoles {
-		add(r)
-	}
-
-	return out, nil
-}

internal/rbac/group_test.go

@@ -1,209 +0,0 @@
-package rbac
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
-)
-
-const groupSchema = `
-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 groups (
-	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), name TEXT NOT NULL, role TEXT CHECK (role IN ('user','tenant_admin')),
-	created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-CREATE TABLE IF NOT EXISTS group_members (
-	group_id UUID NOT NULL REFERENCES groups(id) ON DELETE CASCADE, user_id UUID NOT NULL REFERENCES users(id),
-	added_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (group_id, user_id)
-);`
-
-func setupGroupTestDB(t *testing.T, dbName 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, groupSchema); 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
-}
-
-func createTestUser(t *testing.T, pool *pgxpool.Pool, email string) string {
-	t.Helper()
-	u, err := user.NewTenantUserStore(pool).Create(context.Background(), email, "Test")
-	if err != nil {
-		t.Fatalf("testuser anlegen: %v", err)
-	}
-	return u.ID
-}
-
-// Akzeptanzkriterium 1: Gruppen anlegen und Benutzer zuordnen.
-func TestGroup_CreateAndAddMember(t *testing.T) {
-	pool := setupGroupTestDB(t, "test_rbac03_create")
-	gs := NewGroupStore(pool)
-	ctx := context.Background()
-
-	g, err := gs.CreateGroup(ctx, "Buchhaltung")
-	if err != nil {
-		t.Fatalf("create group: %v", err)
-	}
-	userID := createTestUser(t, pool, "alice@example.com")
-
-	if err := gs.AddMember(ctx, g.ID, userID); err != nil {
-		t.Fatalf("add member: %v", err)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 1: Gruppenrolle wirkt auf ALLE aktuellen
-// Mitglieder.
-func TestGroup_RoleAffectsAllCurrentMembers(t *testing.T) {
-	pool := setupGroupTestDB(t, "test_rbac03_roleall")
-	gs := NewGroupStore(pool)
-	ctx := context.Background()
-
-	g, err := gs.CreateGroup(ctx, "Admins")
-	if err != nil {
-		t.Fatalf("create group: %v", err)
-	}
-	if err := gs.SetGroupRole(ctx, g.ID, RoleTenantAdmin); err != nil {
-		t.Fatalf("set group role: %v", err)
-	}
-
-	alice := createTestUser(t, pool, "alice@example.com")
-	bob := createTestUser(t, pool, "bob@example.com")
-	if err := gs.AddMember(ctx, g.ID, alice); err != nil {
-		t.Fatalf("add alice: %v", err)
-	}
-	if err := gs.AddMember(ctx, g.ID, bob); err != nil {
-		t.Fatalf("add bob: %v", err)
-	}
-
-	for _, uid := range []string{alice, bob} {
-		perms, err := gs.EffectivePermissionsForUser(ctx, nil, uid)
-		if err != nil {
-			t.Fatalf("effective permissions fuer %s: %v", uid, err)
-		}
-		if !contains(perms, PermManageUsers) {
-			t.Fatalf("mitglied %s sollte tenant_admin-rechte ueber die gruppe haben, habe %v", uid, perms)
-		}
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 2: Entfernen aus der Gruppe entzieht die
-// gruppenbasierten Rechte sofort.
-func TestGroup_RemoveMemberRevokesRightsImmediately(t *testing.T) {
-	pool := setupGroupTestDB(t, "test_rbac03_remove")
-	gs := NewGroupStore(pool)
-	ctx := context.Background()
-
-	g, _ := gs.CreateGroup(ctx, "Admins")
-	_ = gs.SetGroupRole(ctx, g.ID, RoleTenantAdmin)
-	userID := createTestUser(t, pool, "alice@example.com")
-	_ = gs.AddMember(ctx, g.ID, userID)
-
-	perms, err := gs.EffectivePermissionsForUser(ctx, nil, userID)
-	if err != nil {
-		t.Fatalf("effective permissions (mitglied): %v", err)
-	}
-	if !contains(perms, PermManageUsers) {
-		t.Fatal("erwartet tenant_admin-rechte als mitglied")
-	}
-
-	if err := gs.RemoveMember(ctx, g.ID, userID); err != nil {
-		t.Fatalf("remove member: %v", err)
-	}
-
-	perms, err = gs.EffectivePermissionsForUser(ctx, nil, userID)
-	if err != nil {
-		t.Fatalf("effective permissions (entfernt): %v", err)
-	}
-	if contains(perms, PermManageUsers) {
-		t.Fatal("erwartet KEINE tenant_admin-rechte nach entfernen aus der gruppe")
-	}
-}
-
-// Akzeptanzkriterium 3: Loeschen einer Gruppe entzieht Rechte sauber, ohne
-// das Benutzerkonto zu loeschen.
-func TestGroup_DeleteGroupRevokesRightsWithoutDeletingUser(t *testing.T) {
-	pool := setupGroupTestDB(t, "test_rbac03_delete")
-	gs := NewGroupStore(pool)
-	us := user.NewTenantUserStore(pool)
-	ctx := context.Background()
-
-	g, _ := gs.CreateGroup(ctx, "Temp")
-	_ = gs.SetGroupRole(ctx, g.ID, RoleTenantAdmin)
-	userID := createTestUser(t, pool, "alice@example.com")
-	_ = gs.AddMember(ctx, g.ID, userID)
-
-	if err := gs.DeleteGroup(ctx, g.ID); err != nil {
-		t.Fatalf("delete group: %v", err)
-	}
-
-	perms, err := gs.EffectivePermissionsForUser(ctx, nil, userID)
-	if err != nil {
-		t.Fatalf("effective permissions: %v", err)
-	}
-	if contains(perms, PermManageUsers) {
-		t.Fatal("erwartet keine rechte mehr nach loeschen der gruppe")
-	}
-
-	if _, err := us.Get(ctx, userID); err != nil {
-		t.Fatalf("benutzerkonto haette erhalten bleiben muessen: %v", err)
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 3: Gruppen sind sauber tenant-isoliert.
-func TestGroup_TenantIsolation(t *testing.T) {
-	poolA := setupGroupTestDB(t, "test_rbac03_tenanta")
-	poolB := setupGroupTestDB(t, "test_rbac03_tenantb")
-	gsA := NewGroupStore(poolA)
-	ctx := context.Background()
-
-	if _, err := gsA.CreateGroup(ctx, "Nur-Tenant-A"); err != nil {
-		t.Fatalf("create group a: %v", err)
-	}
-
-	var countB int
-	if err := poolB.QueryRow(ctx, `SELECT count(*) FROM groups`).Scan(&countB); err != nil {
-		t.Fatalf("count tenant b: %v", err)
-	}
-	if countB != 0 {
-		t.Fatalf("tenant b sollte keine gruppen aus tenant a sehen, habe %d", countB)
-	}
-}

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/0004_config_values.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS config_value_history;
+DROP TABLE IF EXISTS config_values;

migrations/0004_config_values.up.sql

@@ -0,0 +1,23 @@
+-- Zentraler Konfigurationsdienst (CFG-01, siehe core-kanban/tickets/CFG-01.md).
+-- scope = 'global' fuer globale Defaults, sonst der Tenant-Slug. config_values
+-- haelt den AKTUELLEN Stand je (key, scope); config_value_history haelt JEDE
+-- Aenderung fest (Akzeptanzkriterium 2: versioniert nachvollziehbar).
+CREATE TABLE config_values (
+    key        TEXT NOT NULL,
+    scope      TEXT NOT NULL CHECK (scope <> ''),
+    value      TEXT NOT NULL,
+    version    INT NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (key, scope)
+);
+
+CREATE TABLE config_value_history (
+    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    key        TEXT NOT NULL,
+    scope      TEXT NOT NULL,
+    value      TEXT NOT NULL,
+    version    INT NOT NULL,
+    changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX config_value_history_key_scope_idx ON config_value_history (key, scope, version);

migrations/0005_notification_jobs.down.sql

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

migrations/0005_notification_jobs.up.sql

@@ -0,0 +1,20 @@
+-- Benachrichtigungs-Dispatcher-Warteschlange (CFG-02, siehe
+-- core-kanban/tickets/CFG-02.md). Postgres-basiert statt Redis/AMQP
+-- (Projekt-Konvention, siehe nexarch-state.json techstack.job_queue) —
+-- Zeilen ueberleben einen Neustart des Dispatcher-Prozesses unveraendert
+-- (Akzeptanzkriterium 3).
+CREATE TABLE notification_jobs (
+    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    channel         TEXT NOT NULL,
+    recipient       TEXT NOT NULL,
+    payload         JSONB NOT NULL DEFAULT '{}'::jsonb,
+    status          TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),
+    attempts        INT NOT NULL DEFAULT 0,
+    max_attempts    INT NOT NULL DEFAULT 5,
+    next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    last_error      TEXT,
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at      TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX notification_jobs_due_idx ON notification_jobs (status, next_attempt_at);

migrations/0006_notification_channels.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS in_app_notifications;
+DROP TABLE IF EXISTS notification_templates;

migrations/0006_notification_channels.up.sql

@@ -0,0 +1,28 @@
+-- Benachrichtigungs-Kanaele: Vorlagen (E-Mail) + In-App-Nachrichten
+-- (CFG-03, siehe core-kanban/tickets/CFG-03.md). Beide leben in der
+-- Registry-DB, analog zu feature_flags/config_values — modulübergreifende
+-- Konfiguration/UI-Zustand, keine Mandanten-Geschaeftsdaten.
+
+-- tenant_slug = 'global' ist der Fallback-Wert, wenn ein Tenant keine
+-- eigene Vorlage gesetzt hat (Akzeptanzkriterium 3: Vorlagen pro Tenant
+-- anpassbar, mit sinnvollem Default).
+CREATE TABLE notification_templates (
+    tenant_slug TEXT NOT NULL,
+    key         TEXT NOT NULL,
+    subject     TEXT NOT NULL,
+    body        TEXT NOT NULL,
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (tenant_slug, key)
+);
+
+CREATE TABLE in_app_notifications (
+    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    tenant_slug TEXT NOT NULL,
+    user_id     TEXT NOT NULL,
+    title       TEXT NOT NULL,
+    body        TEXT NOT NULL,
+    read_at     TIMESTAMPTZ,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX in_app_notifications_user_idx ON in_app_notifications (tenant_slug, user_id, created_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);

migrations/tenant/0003_groups.down.sql

@@ -1,2 +0,0 @@
-DROP TABLE IF EXISTS group_members;
-DROP TABLE IF EXISTS groups;

migrations/tenant/0003_groups.up.sql

@@ -1,21 +0,0 @@
--- Gruppen/Abteilungen mit Rollenzuweisung auf Gruppenebene (RBAC-03, siehe
--- core-kanban/tickets/RBAC-03.md). Lebt in der Tenant-Datenbank (Modell C) —
--- Gruppen sind implizit tenant-isoliert, da jede Tenant-DB ihre eigenen hat.
-CREATE TABLE groups (
-    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    name       TEXT NOT NULL,
-    role       TEXT CHECK (role IN ('user', 'tenant_admin')),
-    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-
--- ON DELETE CASCADE: Loeschen einer Gruppe entzieht die gruppenbasierten
--- Rechte automatisch, ohne Benutzerkonten selbst zu beruehren
--- (Akzeptanzkriterium 3).
-CREATE TABLE group_members (
-    group_id UUID NOT NULL REFERENCES groups(id) ON DELETE CASCADE,
-    user_id  UUID NOT NULL REFERENCES users(id),
-    added_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-    PRIMARY KEY (group_id, user_id)
-);
-
-CREATE INDEX group_members_user_idx ON group_members (user_id);

scripts/reset-test-env.sh

@@ -1,23 +1,11 @@
 #!/usr/bin/env bash
-# Setzt die nexarch-Testumgebung zurueck: loescht die geteilte
-# Registry-Tabelle "tenants" in der postgres-Wartungsdatenbank sowie alle
-# tenant_*-Datenbanken. Noetig, weil verschiedene Feature-Branches
-# unterschiedliche Registry-Schemata erwarten, aber dieselbe physische
-# Postgres-Instanz auf dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
-#
-# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/reset-test-env.sh
 set -euo pipefail
-
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 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;"
-
 dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
 for db in $dbs; do
 	psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
 done
-
 echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."

scripts/run-checks.sh

@@ -1,24 +1,12 @@
 #!/usr/bin/env bash
-# Ein-Kommando-Pruefung fuer den aktuellen Code-Stand auf dem Testhost:
-# Registry+Tenant-DBs zuruecksetzen, dann build/vet/test in einem Rutsch.
-# -p 1 ist Pflicht, da mehrere Pakete dieselbe physische Registry-Tabelle auf
-# dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
-#
-# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/run-checks.sh
 set -euo pipefail
-
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 cd "$(dirname "$0")/.."
-
 NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
-
 export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
-
 echo "== go build =="
 go build ./...
-
 echo "== go vet =="
 go vet ./...
-
 echo "== go test (-p 1) =="
 go test ./... -p 1 -count=1