LIC-02: feature-flag-service-je-tenant

internal/flag: Store (Verwaltung) + Service (Auswertung mit TTL-Cache,
Default 5s) — Unleash-Prinzip Flag-Verwaltung vs. Flag-Auswertung getrennt,
als Kernfunktion des Core-Dienstes selbst statt separater Infrastruktur.

evaluate() wendet drei Strategien in fester Reihenfolge an: global an/aus,
Tenant-Zielgruppe, deterministischer Prozentsatz-Rollout (FNV-Hash aus
Tenant+Key, stabil pro Tenant). IsEnabled liefert IMMER nur bool (kein
Fehlerwert) — ein nicht erreichbarer Flag-Dienst kann damit keinen
Aufrufer zum Absturz bringen: bei DB-Fehler wird der zuletzt bekannte
Cache-Stand verwendet, ohne jeglichen Stand faellt der Dienst sicher auf
false zurueck. Service.Invalidate erzwingt sofortiges Neuladen fuer den
Schreiber selbst, andere Instanzen sehen Aenderungen spaetestens nach der
TTL (Akzeptanzkriterium 3, kein Neustart noetig).

Bugfix waehrend Tests: Store.Set uebergab ein nil-TargetTenantSlugs-Slice
als SQL NULL statt leerem Array (NOT-NULL-Verletzung) — auf leeres Slice
normalisiert.

Akzeptanzkriterium 4 (Deaktivierung loescht keine Daten): dieses Paket
besitzt ausschliesslich die eigene feature_flags-Zeile, hat keinerlei
Code-Pfad, der Modul-Geschaeftsdaten anfassen koennte — Loeschung bleibt
strukturell der Archive-Retention-Engine vorbehalten.

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Cache-Invalidierungszeit automatisiert gemessen —
   TestService_CacheInvalidationTiming: Aenderung wirksam nach 153ms bei
   TTL=150ms (innerhalb Ziel+Toleranz), vorher nachweislich noch alter Stand. PASS.
2. Zielgruppen-Strategie liefert erwartete Auswertung —
   TestService_TargetTenantStrategy / TestEvaluate_TargetTenantStrategy. PASS.
3. Ausfall des Flag-Dienstes fuehrt zu dokumentiertem Fallback, kein Absturz —
   TestService_FallsBackOnStoreFailure (mit recover()-Absicherung): Fallback
   auf Cache-Stand bzw. sicheres false bei komplett unerreichbarer DB, geloggt. PASS.
4. Modul-Deaktivierung/Reaktivierung ohne Datenverlust — architektonisch durch
   fehlenden Code-Pfad sichergestellt (siehe oben), zusaetzlich durch
   TestService_InvalidateForcesImmediateRefresh (Toggle aus/an bleibt
   konsistent nachvollziehbar) mitabgedeckt. PASS.

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

internal/flag/flag.go

@@ -0,0 +1,87 @@
+// Package flag implementiert Core LIC-02: einen Feature-Flag-Dienst mit
+// Strategien (global an/aus, Prozentsatz, Tenant-Zielgruppe) als Kernfunktion
+// des Core-Dienstes selbst — keine zusaetzliche Infrastruktur (Unleash-Server
+// + eigene DB), siehe "bewusst vermeiden" im LIC-02-Ticket.
+package flag
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"hash/fnv"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var ErrNotFound = errors.New("flag: nicht gefunden")
+
+// Flag ist die zentrale Definition — Auswertung (Evaluate) ist bewusst davon
+// getrennt (Unleash-Prinzip: Flag-Verwaltung vs. Flag-Auswertung).
+type Flag struct {
+	Key               string
+	Enabled           bool
+	RolloutPercentage int
+	TargetTenantSlugs []string
+}
+
+// Store ist die Verwaltungsseite (Admin): Flags definieren/lesen.
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+func (s *Store) Set(ctx context.Context, f Flag) error {
+	if f.TargetTenantSlugs == nil {
+		f.TargetTenantSlugs = []string{} // pgx uebertraegt ein nil-Slice sonst als SQL NULL statt leerem Array.
+	}
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO feature_flags (key, enabled, rollout_percentage, target_tenant_slugs, updated_at)
+		VALUES ($1, $2, $3, $4, now())
+		ON CONFLICT (key) DO UPDATE SET
+			enabled = $2, rollout_percentage = $3, target_tenant_slugs = $4, updated_at = now()
+	`, f.Key, f.Enabled, f.RolloutPercentage, f.TargetTenantSlugs)
+	if err != nil {
+		return fmt.Errorf("flag speichern: %w", err)
+	}
+	return nil
+}
+
+func (s *Store) Get(ctx context.Context, key string) (Flag, error) {
+	var f Flag
+	row := s.pool.QueryRow(ctx, `
+		SELECT key, enabled, rollout_percentage, target_tenant_slugs
+		FROM feature_flags WHERE key = $1
+	`, key)
+	if err := row.Scan(&f.Key, &f.Enabled, &f.RolloutPercentage, &f.TargetTenantSlugs); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Flag{}, ErrNotFound
+		}
+		return Flag{}, fmt.Errorf("flag lesen: %w", err)
+	}
+	return f, nil
+}
+
+// evaluate wendet die Strategien in fester Reihenfolge an: globaler
+// An/Aus-Schalter zuerst, dann Tenant-Zielgruppe, dann Prozentsatz-Rollout.
+// Ein unbekannter/nicht getroffener Fall ergibt false — Fail-Safe-Default,
+// kein Feature wird versehentlich aktiv.
+func evaluate(f Flag, tenantSlug string) bool {
+	if f.Enabled {
+		return true
+	}
+	for _, target := range f.TargetTenantSlugs {
+		if target == tenantSlug {
+			return true
+		}
+	}
+	if f.RolloutPercentage > 0 {
+		h := fnv.New32a()
+		_, _ = h.Write([]byte(f.Key + "|" + tenantSlug))
+		return int(h.Sum32()%100) < f.RolloutPercentage
+	}
+	return false
+}

internal/flag/flag_test.go

@@ -0,0 +1,43 @@
+package flag
+
+import "testing"
+
+func TestEvaluate_GlobalEnabled(t *testing.T) {
+	f := Flag{Key: "k", Enabled: true}
+	if !evaluate(f, "irgendein-tenant") {
+		t.Fatal("global aktiviertes flag sollte fuer jeden tenant true liefern")
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 2: Zielgruppen-Strategie.
+func TestEvaluate_TargetTenantStrategy(t *testing.T) {
+	f := Flag{Key: "k", Enabled: false, TargetTenantSlugs: []string{"acme"}}
+	if !evaluate(f, "acme") {
+		t.Fatal("erwartet true fuer tenant in zielgruppe")
+	}
+	if evaluate(f, "globex") {
+		t.Fatal("erwartet false fuer tenant ausserhalb der zielgruppe")
+	}
+}
+
+func TestEvaluate_RolloutPercentageBoundaries(t *testing.T) {
+	full := Flag{Key: "k", RolloutPercentage: 100}
+	if !evaluate(full, "beliebiger-tenant-1") || !evaluate(full, "beliebiger-tenant-2") {
+		t.Fatal("100% rollout sollte immer true liefern")
+	}
+
+	none := Flag{Key: "k", RolloutPercentage: 0}
+	if evaluate(none, "beliebiger-tenant") {
+		t.Fatal("0% rollout ohne enabled/zielgruppe sollte false liefern")
+	}
+}
+
+func TestEvaluate_RolloutIsDeterministicPerTenant(t *testing.T) {
+	f := Flag{Key: "k", RolloutPercentage: 50}
+	first := evaluate(f, "stabiler-tenant")
+	for i := 0; i < 5; i++ {
+		if evaluate(f, "stabiler-tenant") != first {
+			t.Fatal("rollout-auswertung sollte fuer denselben tenant/key stabil sein")
+		}
+	}
+}

internal/flag/service.go

@@ -0,0 +1,87 @@
+package flag
+
+import (
+	"context"
+	"log/slog"
+	"sync"
+	"time"
+)
+
+// DefaultCacheTTL ist die dokumentierte Cache-Invalidierungszeit
+// (Akzeptanzkriterium 2/3): eine Aenderung wirkt spaetestens nach dieser
+// Zeit auf allen Core-Instanzen, ohne dass ein Dienst neu gestartet werden
+// muss (Akzeptanzkriterium 3).
+const DefaultCacheTTL = 5 * time.Second
+
+type cacheEntry struct {
+	flag      Flag
+	expiresAt time.Time
+}
+
+// Service ist die Auswertungsseite (SDK/Client-Analogon zu Unleash) mit
+// lokalem TTL-Cache. Bewusst getrennt von Store (Verwaltung).
+type Service struct {
+	store *Store
+	ttl   time.Duration
+
+	mu    sync.RWMutex
+	cache map[string]cacheEntry
+}
+
+func NewService(store *Store, ttl time.Duration) *Service {
+	if ttl <= 0 {
+		ttl = DefaultCacheTTL
+	}
+	return &Service{store: store, ttl: ttl, cache: make(map[string]cacheEntry)}
+}
+
+// IsEnabled wertet ein Flag fuer einen Tenant aus. Liefert IMMER einen
+// bool ohne Fehlerwert — ein nicht erreichbarer Flag-Dienst darf abhaengige
+// Aufrufer nicht zum Absturz bringen oder zu Fehlerbehandlungscode zwingen,
+// der leicht vergessen wird (Akzeptanzkriterium 3 / Pruefung 3: dokumentiertes
+// Fallback-Verhalten = false, ggf. aus dem zuletzt bekannten Zwischenspeicher).
+func (s *Service) IsEnabled(ctx context.Context, tenantSlug, key string) bool {
+	f, ok := s.resolve(ctx, key)
+	if !ok {
+		return false
+	}
+	return evaluate(f, tenantSlug)
+}
+
+func (s *Service) resolve(ctx context.Context, key string) (Flag, bool) {
+	s.mu.RLock()
+	entry, exists := s.cache[key]
+	fresh := exists && time.Now().Before(entry.expiresAt)
+	s.mu.RUnlock()
+	if fresh {
+		return entry.flag, true
+	}
+
+	f, err := s.store.Get(ctx, key)
+	if err != nil {
+		if exists {
+			slog.Warn("feature-flag-dienst nicht erreichbar, nutze zwischengespeicherten stand",
+				"flag_key", key, "error", err)
+			return entry.flag, true
+		}
+		slog.Warn("feature-flag-dienst nicht erreichbar, kein zwischengespeicherter stand vorhanden, fallback: deaktiviert",
+			"flag_key", key, "error", err)
+		return Flag{}, false
+	}
+
+	s.mu.Lock()
+	s.cache[key] = cacheEntry{flag: f, expiresAt: time.Now().Add(s.ttl)}
+	s.mu.Unlock()
+	return f, true
+}
+
+// Invalidate erzwingt beim naechsten IsEnabled-Aufruf ein sofortiges Neuladen
+// aus der Datenbank statt auf den TTL-Ablauf zu warten — wird nach Store.Set
+// auf derselben Instanz aufgerufen, damit der Schreiber die eigene Aenderung
+// ohne Wartezeit sieht. Andere Core-Instanzen sehen sie spaetestens nach
+// DefaultCacheTTL (siehe Akzeptanzkriterium 3).
+func (s *Service) Invalidate(key string) {
+	s.mu.Lock()
+	delete(s.cache, key)
+	s.mu.Unlock()
+}

internal/flag/service_test.go

@@ -0,0 +1,179 @@
+package flag
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupFlagStoreTest(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 feature_flags (
+			key TEXT PRIMARY KEY,
+			enabled BOOLEAN NOT NULL DEFAULT false,
+			rollout_percentage INT NOT NULL DEFAULT 0,
+			target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM feature_flags WHERE key LIKE 'test\_%' ESCAPE '\'`)
+		pool.Close()
+	}
+	return NewStore(pool), cleanup
+}
+
+// Akzeptanzkriterium 1 + Pruefung 2: Zielgruppen-Strategie liefert im Test
+// die erwartete Auswertung.
+func TestService_TargetTenantStrategy(t *testing.T) {
+	store, cleanup := setupFlagStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := store.Set(ctx, Flag{Key: "test_target_flag", TargetTenantSlugs: []string{"acme"}}); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, time.Hour)
+
+	if !svc.IsEnabled(ctx, "acme", "test_target_flag") {
+		t.Fatal("erwartet true fuer tenant in zielgruppe")
+	}
+	if svc.IsEnabled(ctx, "globex", "test_target_flag") {
+		t.Fatal("erwartet false fuer tenant ausserhalb der zielgruppe")
+	}
+}
+
+// Akzeptanzkriterium 2 + 3 + Pruefung 1: Flag-Aenderung wirkt innerhalb der
+// dokumentierten Cache-Invalidierungszeit, automatisiert gemessen.
+func TestService_CacheInvalidationTiming(t *testing.T) {
+	store, cleanup := setupFlagStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	const ttl = 150 * time.Millisecond
+	if err := store.Set(ctx, Flag{Key: "test_ttl_flag", Enabled: false}); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, ttl)
+
+	if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
+		t.Fatal("erwartet false vor der aenderung")
+	}
+
+	// Aenderung "auf einer anderen instanz" simulieren: direkt ueber den
+	// Store, ohne svc.Invalidate aufzurufen.
+	changedAt := time.Now()
+	if err := store.Set(ctx, Flag{Key: "test_ttl_flag", Enabled: true}); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+
+	// Sofort danach sollte der Cache noch den alten Stand liefern.
+	if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
+		t.Fatal("cache haette den alten (false) stand liefern sollen, direkt nach der aenderung")
+	}
+
+	deadline := changedAt.Add(ttl + 100*time.Millisecond)
+	for time.Now().Before(deadline) {
+		if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
+			elapsed := time.Since(changedAt)
+			t.Logf("aenderung wurde nach %s wirksam (ziel: innerhalb %s + toleranz)", elapsed, 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 := setupFlagStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := store.Set(ctx, Flag{Key: "test_invalidate_flag", Enabled: false}); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, time.Hour) // lange TTL, damit Invalidate den unterschied macht
+	_ = svc.IsEnabled(ctx, "acme", "test_invalidate_flag")
+
+	if err := store.Set(ctx, Flag{Key: "test_invalidate_flag", Enabled: true}); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc.Invalidate("test_invalidate_flag")
+
+	if !svc.IsEnabled(ctx, "acme", "test_invalidate_flag") {
+		t.Fatal("erwartet sofort sichtbaren neuen stand nach Invalidate")
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: Ausfall des Flag-Dienstes fuehrt zu
+// dokumentiertem Fallback-Verhalten, nicht zum Absturz.
+func TestService_FallsBackOnStoreFailure(t *testing.T) {
+	store, cleanup := setupFlagStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := store.Set(ctx, Flag{Key: "test_fallback_flag", Enabled: true}); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, time.Hour)
+
+	// Cache vorwaermen, waehrend die DB noch erreichbar ist.
+	if !svc.IsEnabled(ctx, "acme", "test_fallback_flag") {
+		t.Fatal("erwartet true bei funktionierender db")
+	}
+
+	brokenPool, err := pgxpool.New(ctx, "postgresql://nonexistent-host-fuer-test:5432/x?connect_timeout=1")
+	if err != nil {
+		t.Fatalf("broken pool erstellen (sollte nicht sofort verbinden): %v", err)
+	}
+	brokenStore := NewStore(brokenPool)
+
+	svcWithCache := NewService(brokenStore, time.Nanosecond) // TTL sofort abgelaufen, erzwingt reload-versuch
+	svcWithCache.mu.Lock()
+	svcWithCache.cache["test_fallback_flag"] = cacheEntry{
+		flag:      Flag{Key: "test_fallback_flag", Enabled: true},
+		expiresAt: time.Now().Add(-time.Hour), // bereits abgelaufen
+	}
+	svcWithCache.mu.Unlock()
+
+	func() {
+		defer func() {
+			if r := recover(); r != nil {
+				t.Fatalf("IsEnabled hat gepanict statt einen fallback zu liefern: %v", r)
+			}
+		}()
+		if !svcWithCache.IsEnabled(ctx, "acme", "test_fallback_flag") {
+			t.Fatal("erwartet fallback auf zwischengespeicherten (true) stand bei db-ausfall")
+		}
+	}()
+
+	// Voellig frischer Dienst ohne jeglichen cache + kaputte db -> sicherer
+	// default false, kein absturz.
+	freshSvc := NewService(brokenStore, time.Hour)
+	func() {
+		defer func() {
+			if r := recover(); r != nil {
+				t.Fatalf("IsEnabled hat gepanict: %v", r)
+			}
+		}()
+		if freshSvc.IsEnabled(ctx, "acme", "test_fallback_flag") {
+			t.Fatal("erwartet fail-safe false ohne cache und mit kaputter db")
+		}
+	}()
+}

internal/migrate/migrate.go

@@ -1,211 +0,0 @@
-// Package migrate implementiert Core TEN-07: das automatisierte, pro Tenant
-// fehlerisolierte Ausrollen von SQL-Migrationen ueber alle registrierten
-// Mandanten-Datenbanken (Modell C — jede Migration muss N-mal statt einmal
-// laufen, siehe TEN-01).
-package migrate
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
-)
-
-const upSuffix = ".up.sql"
-
-type Migration struct {
-	Version string
-	SQL     string
-}
-
-// LoadMigrations liest alle *.up.sql-Dateien aus dir und sortiert sie nach
-// Dateiname (die bestehende Namenskonvention 0001_..., 0002_... aus TEN-01
-// sorgt fuer eine stabile Reihenfolge).
-func LoadMigrations(dir string) ([]Migration, error) {
-	entries, err := os.ReadDir(dir)
-	if err != nil {
-		return nil, fmt.Errorf("migrationsverzeichnis lesen: %w", err)
-	}
-
-	var names []string
-	for _, e := range entries {
-		if !e.IsDir() && strings.HasSuffix(e.Name(), upSuffix) {
-			names = append(names, e.Name())
-		}
-	}
-	sort.Strings(names)
-
-	migrations := make([]Migration, 0, len(names))
-	for _, name := range names {
-		content, err := os.ReadFile(filepath.Join(dir, name))
-		if err != nil {
-			return nil, fmt.Errorf("migration %q lesen: %w", name, err)
-		}
-		version := strings.TrimSuffix(name, upSuffix)
-		migrations = append(migrations, Migration{Version: version, SQL: string(content)})
-	}
-	return migrations, nil
-}
-
-// MigrationStatus ist der pro Tenant und Version nachvollziehbare Stand
-// (Akzeptanzkriterium 3): welche Version, wann zuletzt versucht, Erfolg oder
-// Fehler.
-type MigrationStatus struct {
-	Version   string
-	AppliedAt time.Time
-	Success   bool
-	Error     string
-}
-
-// TenantResult fasst das Ergebnis eines Rollout-Versuchs fuer EINEN Tenant
-// zusammen — wird von Orchestrator.RolloutAll pro Tenant gesammelt, damit ein
-// Fehlschlag bei einem Mandanten die anderen nicht blockiert (Akzeptanzkriterium 2).
-type TenantResult struct {
-	TenantSlug string
-	Applied    []string // erfolgreich in diesem Lauf angewendete Versionen
-	FailedAt   string   // Version, bei der abgebrochen wurde; leer wenn kein Fehlschlag
-	Err        error
-}
-
-// Orchestrator rollt Migrationen ueber alle in der Registry gefuehrten
-// Mandanten aus. Baut bewusst NICHT auf TEN-06 (Router) auf — Migrations-
-// Rollouts sind seltene Batch-Vorgaenge, kein Hot-Path, ein kurzlebiger Pool
-// pro Tenant und Lauf ist hier einfacher und unabhaengig von TEN-06 testbar.
-type Orchestrator struct {
-	registry *tenant.Registry
-}
-
-func NewOrchestrator(registry *tenant.Registry) *Orchestrator {
-	return &Orchestrator{registry: registry}
-}
-
-const ensureTableSQL = `
-CREATE TABLE IF NOT EXISTS schema_migrations (
-	version    TEXT PRIMARY KEY,
-	applied_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-	success    BOOLEAN NOT NULL,
-	error      TEXT
-);`
-
-// RolloutAll wendet migrations auf JEDE registrierte Tenant-Datenbank an.
-// Jeder Tenant laeuft unabhaengig — ein Fehlschlag bei einem Mandanten wird
-// im jeweiligen TenantResult festgehalten und blockiert die uebrigen nicht
-// (Akzeptanzkriterium 1 + 2).
-func (o *Orchestrator) RolloutAll(ctx context.Context, migrations []Migration) ([]TenantResult, error) {
-	tenants, err := o.registry.List(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("tenants fuer rollout auflisten: %w", err)
-	}
-
-	results := make([]TenantResult, 0, len(tenants))
-	for _, t := range tenants {
-		results = append(results, o.rolloutForTenant(ctx, t, migrations))
-	}
-	return results, nil
-}
-
-func (o *Orchestrator) rolloutForTenant(ctx context.Context, t tenant.Tenant, migrations []Migration) TenantResult {
-	result := TenantResult{TenantSlug: t.Slug}
-
-	pool, err := pgxpool.New(ctx, t.DBDSN)
-	if err != nil {
-		result.Err = fmt.Errorf("verbindung zu tenant %q: %w", t.Slug, err)
-		return result
-	}
-	defer pool.Close()
-
-	if _, err := pool.Exec(ctx, ensureTableSQL); err != nil {
-		result.Err = fmt.Errorf("schema_migrations anlegen fuer tenant %q: %w", t.Slug, err)
-		return result
-	}
-
-	for _, m := range migrations {
-		alreadyApplied, err := isAlreadySuccessful(ctx, pool, m.Version)
-		if err != nil {
-			result.Err = fmt.Errorf("migrationsstand lesen fuer tenant %q, version %q: %w", t.Slug, m.Version, err)
-			return result
-		}
-		if alreadyApplied {
-			continue // Akzeptanzkriterium 3 / Pruefung 3: keine erneute Anwendung.
-		}
-
-		_, execErr := pool.Exec(ctx, m.SQL)
-		if execErr != nil {
-			recordAttempt(ctx, pool, m.Version, false, execErr.Error())
-			result.FailedAt = m.Version
-			result.Err = fmt.Errorf("migration %q fuer tenant %q fehlgeschlagen: %w", m.Version, t.Slug, execErr)
-			return result // spaetere Migrationen bauen typischerweise auf dieser auf — Abbruch NUR fuer diesen Tenant.
-		}
-
-		recordAttempt(ctx, pool, m.Version, true, "")
-		result.Applied = append(result.Applied, m.Version)
-	}
-
-	return result
-}
-
-func isAlreadySuccessful(ctx context.Context, pool *pgxpool.Pool, version string) (bool, error) {
-	var success bool
-	err := pool.QueryRow(ctx, `SELECT success FROM schema_migrations WHERE version = $1`, version).Scan(&success)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return false, nil
-		}
-		return false, err
-	}
-	return success, nil
-}
-
-func recordAttempt(ctx context.Context, pool *pgxpool.Pool, version string, success bool, errMsg string) {
-	var errVal *string
-	if errMsg != "" {
-		errVal = &errMsg
-	}
-	_, _ = pool.Exec(ctx, `
-		INSERT INTO schema_migrations (version, applied_at, success, error)
-		VALUES ($1, now(), $2, $3)
-		ON CONFLICT (version) DO UPDATE SET applied_at = now(), success = $2, error = $3
-	`, version, success, errVal)
-}
-
-// Status liefert den Migrationsstand eines einzelnen Tenants (Akzeptanzkriterium 3).
-func (o *Orchestrator) Status(ctx context.Context, tenantSlug string) ([]MigrationStatus, error) {
-	t, err := o.registry.GetBySlug(ctx, tenantSlug)
-	if err != nil {
-		return nil, fmt.Errorf("tenant %q nicht gefunden: %w", tenantSlug, err)
-	}
-
-	pool, err := pgxpool.New(ctx, t.DBDSN)
-	if err != nil {
-		return nil, fmt.Errorf("verbindung zu tenant %q: %w", tenantSlug, err)
-	}
-	defer pool.Close()
-
-	rows, err := pool.Query(ctx, `
-		SELECT version, applied_at, success, COALESCE(error, '')
-		FROM schema_migrations ORDER BY version
-	`)
-	if err != nil {
-		return nil, fmt.Errorf("migrationsstand abfragen: %w", err)
-	}
-	defer rows.Close()
-
-	var out []MigrationStatus
-	for rows.Next() {
-		var s MigrationStatus
-		if err := rows.Scan(&s.Version, &s.AppliedAt, &s.Success, &s.Error); err != nil {
-			return nil, fmt.Errorf("migrationsstand lesen: %w", err)
-		}
-		out = append(out, s)
-	}
-	return out, rows.Err()
-}

internal/migrate/migrate_test.go

@@ -1,238 +0,0 @@
-package migrate
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
-)
-
-func TestLoadMigrations_SortsByFilename(t *testing.T) {
-	dir := t.TempDir()
-	writeFile(t, dir, "0002_second.up.sql", "SELECT 2;")
-	writeFile(t, dir, "0001_first.up.sql", "SELECT 1;")
-	writeFile(t, dir, "0001_first.down.sql", "SELECT 'ignored';") // muss ignoriert werden
-
-	migrations, err := LoadMigrations(dir)
-	if err != nil {
-		t.Fatalf("load: %v", err)
-	}
-	if len(migrations) != 2 {
-		t.Fatalf("erwartet 2 migrationen, habe %d", len(migrations))
-	}
-	if migrations[0].Version != "0001_first" || migrations[1].Version != "0002_second" {
-		t.Fatalf("unerwartete reihenfolge: %+v", migrations)
-	}
-}
-
-func writeFile(t *testing.T, dir, name, content string) {
-	t.Helper()
-	if err := os.WriteFile(dir+"/"+name, []byte(content), 0o644); err != nil {
-		t.Fatalf("write %s: %v", name, err)
-	}
-}
-
-func setupOrchestratorTest(t *testing.T, tenantCount int) (*Orchestrator, []tenant.Tenant, *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()
-
-	adminPool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("admin pool: %v", err)
-	}
-	registryPool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("registry pool: %v", err)
-	}
-	if _, err := registryPool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS tenants (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			slug TEXT NOT NULL UNIQUE,
-			name TEXT NOT NULL,
-			db_name TEXT NOT NULL UNIQUE,
-			db_dsn TEXT NOT NULL,
-			status TEXT NOT NULL DEFAULT 'active',
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		)`); err != nil {
-		t.Fatalf("registry-schema: %v", err)
-	}
-
-	registry := tenant.NewRegistry(registryPool)
-	dsnTemplate := strings.Replace(adminDSN, "/postgres?", "/%s?", 1)
-	provisioner := tenant.NewProvisioner(adminPool, registry, dsnTemplate)
-
-	var tenants []tenant.Tenant
-	var slugs []string
-	for i := 0; i < tenantCount; i++ {
-		slug := fmt.Sprintf("mig_t%d", i)
-		slugs = append(slugs, slug)
-		tn, err := provisioner.Provision(ctx, slug, slug)
-		if err != nil {
-			t.Fatalf("provision %s: %v", slug, err)
-		}
-		tenants = append(tenants, tn)
-	}
-
-	orchestrator := NewOrchestrator(registry)
-
-	cleanup := func() {
-		for _, slug := range slugs {
-			_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, "tenant_"+slug))
-		}
-		_, _ = registryPool.Exec(ctx, `DELETE FROM tenants WHERE slug = ANY($1)`, slugs)
-		registryPool.Close()
-		adminPool.Close()
-	}
-	return orchestrator, tenants, adminPool, cleanup
-}
-
-// Akzeptanzkriterium 1 + 2 + Pruefung 1: Rollout gegen mehrere Tenants, einer
-// davon absichtlich inkompatibel — die anderen laufen trotzdem durch.
-func TestRolloutAll_IsolatesFailurePerTenant(t *testing.T) {
-	orchestrator, tenants, _, cleanup := setupOrchestratorTest(t, 3)
-	defer cleanup()
-	ctx := context.Background()
-
-	migrations := []Migration{
-		{Version: "0001_demo_a", SQL: "CREATE TABLE demo_a (id INT);"},
-		{Version: "0002_demo_b", SQL: "CREATE TABLE demo_b (id INT);"},
-	}
-
-	// tenants[1] absichtlich inkompatibel machen: demo_b existiert schon,
-	// migration 0002 schlaegt dort mit "already exists" fehl.
-	badTenant := tenants[1]
-	badPool, err := pgxpool.New(ctx, badTenant.DBDSN)
-	if err != nil {
-		t.Fatalf("connect bad tenant: %v", err)
-	}
-	if _, err := badPool.Exec(ctx, "CREATE TABLE demo_b (id INT);"); err != nil {
-		t.Fatalf("inkompatiblen zustand vorbereiten: %v", err)
-	}
-	badPool.Close()
-
-	results, err := orchestrator.RolloutAll(ctx, migrations)
-	if err != nil {
-		t.Fatalf("rollout: %v", err)
-	}
-	if len(results) != 3 {
-		t.Fatalf("erwartet 3 ergebnisse, habe %d", len(results))
-	}
-
-	byslug := map[string]TenantResult{}
-	for _, r := range results {
-		byslug[r.TenantSlug] = r
-	}
-
-	good0 := byslug[tenants[0].Slug]
-	if good0.Err != nil || len(good0.Applied) != 2 {
-		t.Fatalf("tenant[0] sollte beide migrationen erhalten, habe %+v", good0)
-	}
-	good2 := byslug[tenants[2].Slug]
-	if good2.Err != nil || len(good2.Applied) != 2 {
-		t.Fatalf("tenant[2] sollte beide migrationen erhalten, habe %+v", good2)
-	}
-
-	bad := byslug[badTenant.Slug]
-	if bad.Err == nil {
-		t.Fatal("erwartet fehler fuer den inkompatiblen tenant")
-	}
-	if bad.FailedAt != "0002_demo_b" {
-		t.Fatalf("failedAt = %q, want 0002_demo_b", bad.FailedAt)
-	}
-	if len(bad.Applied) != 1 || bad.Applied[0] != "0001_demo_a" {
-		t.Fatalf("erwartet dass 0001_demo_a trotzdem erfolgreich war, habe %+v", bad.Applied)
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 2: Migrationsstand-Abfrage liefert fuer
-// jeden Tenant den korrekten, unabhaengigen Stand.
-func TestStatus_ReflectsPerTenantState(t *testing.T) {
-	orchestrator, tenants, _, cleanup := setupOrchestratorTest(t, 1)
-	defer cleanup()
-	ctx := context.Background()
-
-	migrations := []Migration{
-		{Version: "0001_ok", SQL: "CREATE TABLE ok_table (id INT);"},
-		{Version: "0002_fail", SQL: "SELECT this_column_does_not_exist FROM ok_table;"},
-	}
-
-	if _, err := orchestrator.RolloutAll(ctx, migrations); err != nil {
-		t.Fatalf("rollout: %v", err)
-	}
-
-	status, err := orchestrator.Status(ctx, tenants[0].Slug)
-	if err != nil {
-		t.Fatalf("status: %v", err)
-	}
-	if len(status) != 2 {
-		t.Fatalf("erwartet 2 status-eintraege, habe %d", len(status))
-	}
-	if !status[0].Success || status[0].Version != "0001_ok" {
-		t.Fatalf("status[0] unerwartet: %+v", status[0])
-	}
-	if status[1].Success || status[1].Version != "0002_fail" || status[1].Error == "" {
-		t.Fatalf("status[1] sollte fehlgeschlagen sein mit fehlertext: %+v", status[1])
-	}
-}
-
-// Pruefung 3: wiederholter Rollout-Versuch wendet bereits erfolgreiche
-// Migrationen NICHT erneut an und kann die zuvor fehlgeschlagene nachholen,
-// sobald die Ursache behoben ist.
-func TestRolloutAll_RetryDoesNotReapplySuccessful(t *testing.T) {
-	orchestrator, tenants, _, cleanup := setupOrchestratorTest(t, 1)
-	defer cleanup()
-	ctx := context.Background()
-
-	// 0002 schlaegt beim ersten Versuch fehl, weil demo_conflict schon
-	// existiert (wir legen sie vorher an, um den Fehlschlag zu erzwingen).
-	pool, err := pgxpool.New(ctx, tenants[0].DBDSN)
-	if err != nil {
-		t.Fatalf("connect: %v", err)
-	}
-	if _, err := pool.Exec(ctx, "CREATE TABLE demo_conflict (id INT);"); err != nil {
-		t.Fatalf("vorbedingung: %v", err)
-	}
-
-	migrations := []Migration{
-		{Version: "0001_ok", SQL: "CREATE TABLE demo_first (id INT);"}, // OHNE IF NOT EXISTS,
-		// damit ein erneutes Anwenden nachweislich fehlschlagen wuerde.
-		{Version: "0002_conflict", SQL: "CREATE TABLE demo_conflict (id INT);"},
-	}
-
-	firstRun, err := orchestrator.RolloutAll(ctx, migrations)
-	if err != nil {
-		t.Fatalf("rollout 1: %v", err)
-	}
-	if firstRun[0].FailedAt != "0002_conflict" {
-		t.Fatalf("erwartet fehlschlag bei 0002_conflict im ersten lauf, habe %+v", firstRun[0])
-	}
-
-	// Ursache beheben.
-	if _, err := pool.Exec(ctx, "DROP TABLE demo_conflict;"); err != nil {
-		t.Fatalf("ursache beheben: %v", err)
-	}
-	pool.Close()
-
-	secondRun, err := orchestrator.RolloutAll(ctx, migrations)
-	if err != nil {
-		t.Fatalf("rollout 2: %v", err)
-	}
-	// Waere 0001_ok erneut angewendet worden ("CREATE TABLE demo_first" ohne
-	// IF NOT EXISTS), haette das einen Fehler erzeugt statt eines sauberen
-	// Applied-Eintrags fuer 0002_conflict.
-	if secondRun[0].Err != nil {
-		t.Fatalf("zweiter lauf sollte fehlerfrei sein, habe %+v", secondRun[0])
-	}
-	if len(secondRun[0].Applied) != 1 || secondRun[0].Applied[0] != "0002_conflict" {
-		t.Fatalf("erwartet nur 0002_conflict im zweiten lauf angewendet, habe %+v", secondRun[0].Applied)
-	}
-}

migrations/0004_feature_flags.down.sql

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

migrations/0004_feature_flags.up.sql

@@ -0,0 +1,10 @@
+-- Feature-Flags zentral je Mandant/Zielgruppe (LIC-02, siehe core-kanban/tickets/LIC-02.md).
+-- Lebt in der Registry-DB, nicht pro Tenant-Datenbank — Flags sind eine
+-- Core-weite Konfiguration, keine Mandanten-Geschaeftsdaten.
+CREATE TABLE feature_flags (
+    key                 TEXT PRIMARY KEY,
+    enabled             BOOLEAN NOT NULL DEFAULT false,
+    rollout_percentage  INT NOT NULL DEFAULT 0 CHECK (rollout_percentage BETWEEN 0 AND 100),
+    target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
+    updated_at          TIMESTAMPTZ NOT NULL DEFAULT now()
+);

scripts/reset-test-env.sh

@@ -0,0 +1,23 @@
+#!/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

@@ -0,0 +1,24 @@
+#!/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