michaelschiemer/docs/debugging/additional-refactoring-suggestions.md

Weitere Refactoring-Vorschläge für Discovery Cache

Implementiert: Vorschlag 2 - Cache-Invalidierung bei Datei-Änderungen

✅ Implementiert:

• StalenessChecker::areFilesModifiedSince() - Prüft einzelne Dateien statt nur Verzeichnisse
• DiscoveryCacheManager::invalidateIfFilesChanged() - Invalidiert Cache bei Datei-Änderungen
• DiscoveryCacheManager::extractCriticalFilesFromRegistry() - Extrahiert kritische Dateien aus Registry
• Integration in DiscoveryServiceBootstrapper für automatische Prüfung kritischer Komponenten-Dateien

Weitere Vorschläge

Vorschlag 6: Automatische Datei-Erkennung für kritische Komponenten

Problem: Aktuell müssen kritische Dateien manuell in DiscoveryServiceBootstrapper aufgelistet werden.

Lösung: Automatische Erkennung aller Komponenten-Dateien aus der Registry:

// In DiscoveryCacheManager.php
public function invalidateIfComponentFilesChanged(DiscoveryContext $context): bool
{
    $result = $this->getStandardCache($context);
    
    if (!$result->found || !$result->entry) {
        return false;
    }
    
    $criticalFiles = $this->extractCriticalFilesFromRegistry($result->entry->registry);
    
    if (empty($criticalFiles)) {
        return false;
    }
    
    return $this->invalidateIfFilesChanged($context, $criticalFiles);
}

Vorteil: Keine manuelle Wartung der Datei-Liste nötig.

Vorschlag 7: Watch-Mode für Development

Problem: In Development müssen Entwickler manuell den Cache löschen.

Lösung: Watch-Mode, der automatisch auf Datei-Änderungen reagiert:

// In DiscoveryServiceBootstrapper.php
public function enableWatchMode(array $watchPaths = []): void
{
    $this->watchMode = true;
    $this->watchPaths = $watchPaths;
    
    // Register file watcher
    $this->fileWatcher = new FileWatcher($watchPaths, function($changedFiles) {
        $this->invalidateCacheForFiles($changedFiles);
    });
}

Vorteil: Automatische Cache-Invalidierung während Development.

Vorschlag 8: Cache-Warming mit File-Hash-Verification

Problem: Cache könnte veraltet sein, auch wenn Datei-Modifikationszeiten gleich sind.

Lösung: File-Hash-Verification für kritische Dateien:

// In StalenessChecker.php
public function verifyFileHashes(array $filePaths, array $expectedHashes): bool
{
    foreach ($filePaths as $filePath) {
        if (!isset($expectedHashes[$filePath])) {
            continue;
        }
        
        $currentHash = md5_file($filePath);
        if ($currentHash !== $expectedHashes[$filePath]) {
            return false;
        }
    }
    
    return true;
}

Vorteil: Präzisere Erkennung von Datei-Änderungen, auch bei gleichen Modifikationszeiten.

Vorschlag 9: Incremental Cache Updates

Problem: Bei jeder Datei-Änderung wird der gesamte Cache neu erstellt.

Lösung: Incremental Updates - nur geänderte Komponenten werden neu geladen:

// In DiscoveryCacheManager.php
public function updateCacheIncrementally(DiscoveryContext $context, array $changedFiles): bool
{
    $result = $this->getStandardCache($context);
    
    if (!$result->found || !$result->entry) {
        return false;
    }
    
    $registry = $result->entry->registry;
    
    // Remove entries for changed files
    foreach ($changedFiles as $file) {
        $registry = $this->removeEntriesForFile($registry, $file);
    }
    
    // Re-discover only changed files
    $newEntries = $this->discoverFiles($changedFiles);
    
    // Merge new entries into registry
    $updatedRegistry = $this->mergeRegistry($registry, $newEntries);
    
    // Store updated registry
    return $this->store($context, $updatedRegistry);
}

Vorteil: Deutlich schneller bei kleinen Änderungen.

Vorschlag 10: Cache-Tags für selektive Invalidierung

Problem: Bei Änderungen müssen alle Discovery-Caches gelöscht werden.

Lösung: Cache-Tags für selektive Invalidierung:

// In DiscoveryCacheManager.php
public function invalidateByTag(string $tag): bool
{
    // Invalidate only caches with specific tag
    // e.g., 'component:popover', 'route:api', etc.
    $keys = $this->findCacheKeysByTag($tag);
    
    foreach ($keys as $key) {
        $this->cache->forget($key);
    }
    
    return true;
}

Vorteil: Selektive Invalidierung nur betroffener Caches.

Vorschlag 11: Cache-Metadaten für Debugging

Problem: Schwer zu debuggen, welche Dateien im Cache enthalten sind.

Lösung: Cache-Metadaten mit Datei-Liste:

// In CacheEntry.php
public function __construct(
    public readonly DiscoveryRegistry|array $registry,
    public readonly Timestamp $createdAt,
    public readonly string $version = '',
    public readonly CacheLevel $cacheLevel = CacheLevel::NORMAL,
    public readonly CacheTier $cacheTier = CacheTier::HOT,
    public readonly array $sourceFiles = [], // NEW: List of source files
    public readonly array $fileHashes = []   // NEW: File hashes for verification
) {
}

Vorteil: Besseres Debugging und Verifikation.

Vorschlag 12: Background Cache Refresh

Problem: Cache-Refresh blockiert Request.

Lösung: Background Refresh mit stale-while-revalidate Pattern:

// In DiscoveryCacheManager.php
public function getWithBackgroundRefresh(DiscoveryContext $context): ?DiscoveryRegistry
{
    $result = $this->getStandardCache($context);
    
    if ($result->found && $result->isUsable()) {
        return $result->entry->registry;
    }
    
    // Return stale cache if available
    if ($result->entry !== null) {
        $this->triggerBackgroundRefresh($context);
        return $result->entry->registry;
    }
    
    // No cache available, do synchronous refresh
    return null;
}

Vorteil: Keine Blockierung von Requests während Cache-Refresh.

Empfohlene Implementierungsreihenfolge

1. ✅ Vorschlag 2 (Cache-Invalidierung bei Datei-Änderungen) - IMPLEMENTIERT
2. Vorschlag 6 (Automatische Datei-Erkennung) - Sofortige Verbesserung
3. Vorschlag 11 (Cache-Metadaten) - Für besseres Debugging
4. Vorschlag 7 (Watch-Mode) - Für Development-Quality-of-Life
5. Vorschlag 9 (Incremental Updates) - Für Performance
6. Vorschlag 10 (Cache-Tags) - Für Skalierbarkeit
7. Vorschlag 12 (Background Refresh) - Für Production-Performance
8. Vorschlag 8 (File-Hash-Verification) - Optional, für höchste Präzision

Priorisierung

Hoch (sofort):

• Vorschlag 6: Automatische Datei-Erkennung
• Vorschlag 11: Cache-Metadaten

Mittel (nächste Iteration):

• Vorschlag 7: Watch-Mode
• Vorschlag 9: Incremental Updates

Niedrig (langfristig):

• Vorschlag 10: Cache-Tags
• Vorschlag 12: Background Refresh
• Vorschlag 8: File-Hash-Verification