mivita/dev/subdomain-optimization-grok/MIGRATION_GUIDE.md

Migration Guide - Von altem zu neuem Domain System

Übersicht

Dieser Guide führt Sie durch die Migration vom aktuellen Domain-System zum neuen optimierten System. Die Migration erfolgt schrittweise, um Risiken zu minimieren.

Vor der Migration

1. Backup erstellen

# Datenbank Backup
mysqldump mivita > mivita_backup_$(date +%Y%m%d_%H%M%S).sql

# Code Backup
cp -r app/ app_backup_$(date +%Y%m%d_%H%M%S)/

2. Tests vorbereiten

# Bestehende Tests ausführen
php artisan test

# Domain-spezifische Tests erstellen
php artisan make:test DomainRoutingTest
php artisan make:test SessionDomainSwitchingTest

3. Neue Dateien bereitstellen

# Neue Klassen kopieren
cp dev/subdomain-optimization-grok/src/Domain/DomainType.php app/Domain/
cp dev/subdomain-optimization-grok/src/Domain/DomainContext.php app/Domain/
cp dev/subdomain-optimization-grok/src/Middleware/DomainResolver.php app/Http/Middleware/
cp dev/subdomain-optimization-grok/src/Middleware/DomainSessionHandler.php app/Http/Middleware/
cp dev/subdomain-optimization-grok/src/Services/DomainService.php app/Services/
cp dev/subdomain-optimization-grok/src/Services/DomainCacheManager.php app/Services/
cp dev/subdomain-optimization-grok/src/Providers/RouteServiceProvider.php app/Providers/
cp dev/subdomain-optimization-grok/src/Events/DomainChangedEvent.php app/Events/

Schritt-für-Schritt Migration

Schritt 1: Neue Middleware registrieren (Test-Environment)

Datei: app/Http/Kernel.php

'web' => [
    \App\Http\Middleware\EncryptCookies::class,
    \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,

    // NEUE MIDDLEWARE (nach Cookies, vor Session)
    \App\Http\Middleware\DomainResolver::class,

    \Illuminate\Session\Middleware\StartSession::class,
    \Illuminate\Session\Middleware\AuthenticateSession::class,
    \Illuminate\View\Middleware\ShareErrorsFromSession::class,
    \App\Http\Middleware\VerifyCsrfToken::class,

    // NEUE MIDDLEWARE (nach Session)
    \App\Http\Middleware\DomainSessionHandler::class,

    \Illuminate\Routing\Middleware\SubstituteBindings::class,
    \App\Http\Middleware\Localization::class,
],

Schritt 2: DomainServiceProvider aktualisieren

Datei: app/Providers/DomainServiceProvider.php

public function register()
{
    // DomainService registrieren (bleibt gleich)
    $this->app->singleton(DomainService::class, function ($app) {
        $domainService = new DomainService($app['config']['domains']);
        // ... bestehende Validierung
        return $domainService;
    });

    // DomainContext registrieren (AKTUALISIERT)
    $this->app->singleton(DomainContext::class, function ($app) {
        /** @var DomainService $domainService */
        $domainService = $app->make(DomainService::class);
        $request = $app->make('request');

        $domainInfo = $domainService->parseDomain($request->getHost());

        $userShop = null;
        if ($domainInfo['type'] === 'user-shop' && $domainInfo['subdomain']) {
            $userShop = $domainService->getUserShop($domainInfo['subdomain']);
            if (!$userShop) {
                $domainInfo['type'] = 'unknown';
            }
        }

        if ($domainInfo['type'] === 'main-shop' && $domainInfo['default_user_shop']) {
            $userShop = $domainService->getUserShop($domainInfo['default_user_shop']);
        }

        // NEU: DomainContext::fromArray verwenden
        return DomainContext::fromArray($domainInfo, $userShop);
    });
}

Schritt 3: RouteServiceProvider aktualisieren

Datei: app/Providers/RouteServiceProvider.php

protected function loadDomainAwareRoutes(): void
{
    /** @var DomainContext $context */
    $context = app(DomainContext::class);

    if (config('app.debug')) {
        \Log::channel('domain')->info('loadDomainAwareRoutes', ['context' => $context]);
    }

    // NEUE DOMAIN-TYPES verwenden
    match ($context->type) {
        'main' => $this->loadDomainRoutes('main', 'main.php'),
        'shop' => $this->loadDomainRoutes('shop', 'shop.php'),
        'crm' => $this->loadDomainRoutes('crm', 'crm.php'),
        'portal' => $this->loadDomainRoutes('portal', 'portal.php'),
        'checkout' => $this->loadDomainRoutes('checkout', 'checkout.php'),
        'user-shop' => [
            $this->loadDomainRoutes('user-shop', 'user-shop.php'),
            $this->loadDomainRoutes('portal', 'portal.php'),
        ],
        default => $this->loadAllDomainRoutesForCaching(),
    };
}

Schritt 4: Event-ServiceProvider registrieren

Datei: config/app.php

'providers' => [
    // ... andere Provider
    App\Providers\EventServiceProvider::class,
],

Datei: app/Providers/EventServiceProvider.php

protected $listen = [
    \App\Events\DomainChangedEvent::class => [
        // Optional: Listener für Domain-Änderungen
        // \App\Listeners\DomainChangedListener::class,
    ],
];

Schritt 5: Konfiguration aktualisieren

Datei: config/domains.php (keine Änderungen nötig)

Schritt 6: Tests durchführen

# Grundfunktionalität testen
php artisan tinker

// Domain-Auflösung testen
$domainService = app(\App\Services\DomainService::class);
$context = $domainService->resolveDomain('my.mivita.care');
echo $context; // Sollte DomainType::CRM zeigen

// UserShop testen
$userShop = $domainService->getUserShop('aloevera');
echo $userShop?->name ?? 'UserShop nicht gefunden';

Rollback-Plan

Falls Probleme auftreten:

Schnell-Rollback

# Kernel.php zurücksetzen
git checkout HEAD -- app/Http/Kernel.php

# Neue Middleware auskommentieren
# \App\Http\Middleware\DomainResolver::class,
# \App\Http\Middleware\DomainSessionHandler::class,

Vollständiges Rollback

# Alle neuen Dateien entfernen
rm app/Domain/DomainType.php
rm app/Domain/DomainContext.php
rm app/Http/Middleware/DomainResolver.php
rm app/Http/Middleware/DomainSessionHandler.php
rm app/Services/DomainCacheManager.php
rm app/Events/DomainChangedEvent.php

# Alte Dateien wiederherstellen
git checkout HEAD -- app/Providers/DomainServiceProvider.php
git checkout HEAD -- app/Providers/RouteServiceProvider.php

Nach der Migration

1. Cache leeren

php artisan cache:clear
php artisan config:clear
php artisan route:clear

2. Route-Cache neu aufbauen

php artisan route:cache

3. Tests ausführen

# Vollständige Test-Suite
php artisan test

# Domain-spezifische Tests
php artisan test --filter=Domain

4. Monitoring einrichten

# Domain-Logs überwachen
tail -f storage/logs/domain-*.log

# Performance überwachen
php artisan tinker

$cacheManager = app(\App\Services\DomainCacheManager::class);
$stats = $cacheManager->getCacheStatistics();
$health = $cacheManager->performHealthCheck();

Häufige Probleme und Lösungen

Problem 1: Session-Konflikte

Symptom: Zwei Sessions werden erstellt

Lösung:

• Sicherstellen, dass DomainResolver NACH Cookies aber VOR Session läuft
• DomainSessionHandler NACH Session-Start ausführen

Problem 2: UserShop wird nicht beibehalten

Symptom: Beim Wechsel von Shop zu in. geht UserShop verloren

Lösung:

• Überprüfen, dass shouldPreserveSession() korrekt implementiert ist
• DomainSessionHandler muss UserShop-Daten korrekt setzen

Problem 3: Performance-Probleme

Symptom: Langsame Domain-Auflösung

Lösung:

# Cache leeren
php artisan cache:clear

# Cache vorwärmen
php artisan tinker
$cacheManager = app(\App\Services\DomainCacheManager::class);
$cacheManager->warmupCache(['mivita.care', 'my.mivita.care'], ['aloevera']);

Problem 4: Route-Loading Fehler

Symptom: Falsche Routen werden geladen

Lösung:

• Route-Cache leeren: php artisan route:clear
• Domain-Kontext überprüfen im Debug-Modus
• Route-Dateien auf Existenz prüfen

Performance-Optimierungen

Cache-Konfiguration

Datei: config/cache.php

'stores' => [
    'redis' => [
        'driver' => 'redis',
        'connection' => 'cache',
        'lock_connection' => 'default',
    ],
],

Queue für Cache-Operationen

# Cache-Operationen asynchron verarbeiten
php artisan queue:work

Monitoring und Alerting

Log-Konfiguration

Datei: config/logging.php

'channels' => [
    'domain' => [
        'driver' => 'daily',
        'path' => storage_path('logs/domain.log'),
        'level' => 'debug',
        'days' => 30,
    ],
],

Health-Checks

# Domain-System Health-Check
curl https://mivita.care/health/domain

Support

Bei Problemen:

1. Logs überprüfen: storage/logs/domain-*.log
2. Debug-Modus aktivieren: .env APP_DEBUG=true
3. Cache-Statistiken prüfen
4. Domain-Service direkt testen

Zeitplan

• Tag 1: Neue Dateien bereitstellen und testen
• Tag 2: Middleware-Migration in Test-Environment
• Tag 3: Vollständige Migration in Staging
• Tag 4: Production-Deployment mit Rollback-Plan
• Tag 5: Monitoring und Optimierung

Checklisten

Pre-Migration ✅

• Backup erstellt
• Tests vorbereitet
• Neue Dateien bereitgestellt
• Rollback-Plan dokumentiert

Post-Migration ✅

• Cache geleert
• Routes gecacht
• Tests bestanden
• Monitoring aktiv
• Performance baseline etabliert