update 20.10.2025

dev/subdomain-optimization-grok/README.md

@@ -0,0 +1,241 @@
+# Domain Management System - Optimierte Architektur
+
+## Übersicht
+
+Dieses optimierte Domain Management System löst die Session-Probleme des aktuellen Systems und bietet eine saubere, wartbare Architektur für Multi-Domain-Anwendungen.
+
+## Hauptprobleme der aktuellen Implementierung
+
+1. **Session-Konflikte**: DomainResolver wird zu früh ausgeführt, bevor die Session-Middleware verfügbar ist
+2. **Zwei Sessions**: Dadurch werden zwei separate Sessions erstellt
+3. **Komplexe Logik**: Domain-Auflösung und Session-Management sind eng gekoppelt
+4. **Performance**: Ineffizientes Caching und wiederholte DB-Abfragen
+
+## Neue Architektur
+
+### Kernkomponenten
+
+```
+├── DomainResolver (Middleware) - Reine Domain-Auflösung
+├── DomainContext (DTO) - Unveränderlicher Domain-Kontext
+├── DomainService - Zentraler Service für Domain-Logik
+├── SessionHandler - Event-basiertes Session-Management
+├── RouteService - Domain-aware Route-Loading
+└── CacheManager - Optimiertes Caching
+```
+
+### Middleware-Reihenfolge (Behoben)
+
+```php
+'web' => [
+    \App\Http\Middleware\EncryptCookies::class,
+    \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
+    \App\Http\Middleware\DomainResolver::class,        // ✅ Nach Cookies, vor Session
+    \Illuminate\Session\Middleware\StartSession::class,
+    \App\Http\Middleware\DomainSessionHandler::class,  // ✅ Nach Session-Start
+    // ... weitere Middleware
+]
+```
+
+## Hauptverbesserungen
+
+### 1. Session-Problem gelöst
+
+- **DomainResolver**: Läuft nach Cookie-Encryption, aber vor Session-Start
+- **DomainSessionHandler**: Verarbeitet Session-Updates nach Session-Initialisierung
+- **Event-basierte Kommunikation**: Domain-Änderungen werden als Events behandelt
+
+### 2. Saubere Trennung der Verantwortlichkeiten
+
+- **DomainResolver**: Nur Domain-Auflösung und Kontext-Erstellung
+- **DomainSessionHandler**: Nur Session-Management
+- **DomainService**: Reine Geschäftslogik
+
+### 3. Performance-Optimierungen
+
+- **Intelligentes Caching**: Mehrere Cache-Schichten
+- **Lazy Loading**: UserShop-Daten werden nur bei Bedarf geladen
+- **Batch-Operations**: Mehrere Domain-Validierungen in einem Durchgang
+
+### 4. Domain-Types
+
+```php
+enum DomainType: string {
+    case MAIN = 'main';           // mivita.care
+    case SHOP = 'shop';           // mivita.shop
+    case CRM = 'crm';             // my.mivita.care
+    case PORTAL = 'portal';       // in.mivita.care
+    case CHECKOUT = 'checkout';   // checkout.mivita.care
+    case USER_SHOP = 'user-shop'; // {slug}.mivita.care
+    case UNKNOWN = 'unknown';
+}
+```
+
+## Implementierung
+
+### DomainResolver (Neue Middleware)
+
+```php
+class DomainResolver
+{
+    public function handle(Request $request, Closure $next)
+    {
+        // 1. Domain parsen und Context erstellen
+        $context = $this->resolveDomain($request->getHost());
+
+        // 2. Context in Request speichern (nicht Session!)
+        $request->merge(['domain_context' => $context]);
+
+        // 3. Session-Domain setzen für Cookies
+        $this->setSessionDomain($context);
+
+        // 4. Domain-Changed Event auslösen (falls nötig)
+        if ($this->domainChanged($context)) {
+            event(new DomainChangedEvent($context));
+        }
+
+        return $next($request);
+    }
+}
+```
+
+### DomainSessionHandler (Neue Middleware)
+
+```php
+class DomainSessionHandler
+{
+    public function handle(Request $request, Closure $next)
+    {
+        $response = $next($request);
+
+        // Session nur updaten, wenn Domain-Context verfügbar
+        if ($context = $request->get('domain_context')) {
+            $this->updateSessionForDomain($context);
+        }
+
+        return $response;
+    }
+
+    private function updateSessionForDomain(DomainContext $context): void
+    {
+        // UserShop in Session setzen/behalten
+        if ($context->isUserShop()) {
+            Session::put('user_shop', $context->userShop);
+            Session::put('user_shop_domain', $context->host);
+        }
+
+        // Session-Domain aktualisieren
+        Config::set('session.domain', $this->getSessionDomain($context));
+    }
+}
+```
+
+### DomainService (Optimierte Version)
+
+```php
+class DomainService
+{
+    public function resolveDomain(string $host): DomainContext
+    {
+        // 1. Host normalisieren
+        $normalizedHost = $this->normalizeHost($host);
+
+        // 2. Domain-Info parsen
+        $domainInfo = $this->parseDomain($normalizedHost);
+
+        // 3. Domain-Type bestimmen
+        $type = $this->determineDomainType($domainInfo);
+
+        // 4. UserShop laden (nur bei Bedarf)
+        $userShop = $this->loadUserShopIfNeeded($type, $domainInfo);
+
+        return new DomainContext($type, $normalizedHost, $domainInfo['subdomain'], $userShop);
+    }
+
+    private function loadUserShopIfNeeded(DomainType $type, array $domainInfo): ?UserShop
+    {
+        if (!$type->isUserShop()) {
+            return null;
+        }
+
+        return $this->getUserShop($domainInfo['subdomain']);
+    }
+}
+```
+
+## Migration Guide
+
+### Schritt 1: Neue Dateien hinzufügen
+
+```bash
+# Neue Middleware
+cp dev/subdomain-optimization-grok/src/Middleware/DomainResolver.php app/Http/Middleware/
+cp dev/subdomain-optimization-grok/src/Middleware/DomainSessionHandler.php app/Http/Middleware/
+
+# Neue Services
+cp dev/subdomain-optimization-grok/src/Services/DomainService.php app/Services/
+cp dev/subdomain-optimization-grok/src/Services/DomainCacheManager.php app/Services/
+
+# Neue Domain-Klassen
+cp dev/subdomain-optimization-grok/src/Domain/DomainContext.php app/Domain/
+cp dev/subdomain-optimization-grok/src/Domain/DomainType.php app/Domain/
+```
+
+### Schritt 2: Kernel.php aktualisieren
+
+```php
+'web' => [
+    // ... existing middleware ...
+    \App\Http\Middleware\DomainResolver::class,        // Nach Cookies
+    \Illuminate\Session\Middleware\StartSession::class,
+    \App\Http\Middleware\DomainSessionHandler::class,  // Nach Session
+    // ... rest of middleware ...
+],
+```
+
+### Schritt 3: DomainServiceProvider aktualisieren
+
+```php
+// Alte DomainResolver-Middleware entfernen
+// Neue Services registrieren
+```
+
+## Vorteile der neuen Architektur
+
+1. **Session-Konflikte behoben**: Klare Trennung zwischen Domain-Auflösung und Session-Management
+2. **Bessere Performance**: Optimiertes Caching und Lazy Loading
+3. **Wartbarkeit**: Klare Trennung der Verantwortlichkeiten
+4. **Testbarkeit**: Jede Komponente kann isoliert getestet werden
+5. **Skalierbarkeit**: Einfache Erweiterung um neue Domain-Types
+6. **Event-Driven**: Lose Kopplung durch Events
+
+## Tests
+
+```bash
+# Unit Tests
+php artisan test tests/Unit/Domain/
+
+# Feature Tests
+php artisan test tests/Feature/DomainRouting/
+
+# Integration Tests
+php artisan test tests/Feature/SessionDomainSwitching/
+```
+
+## Monitoring
+
+Das neue System integriert sich nahtlos mit Laravel's Logging und Monitoring:
+
+```php
+// Domain-Resolution Metrics
+Log::channel('domain')->info('Domain resolved', [
+    'host' => $host,
+    'type' => $context->type,
+    'resolution_time' => $time,
+    'cache_hit' => $cacheHit
+]);
+```
+
+## Fazit
+
+Diese optimierte Architektur löst alle identifizierten Probleme und bietet eine solide Grundlage für zukünftige Erweiterungen des Domain-Systems.