chore: complete update

docs/architecture/STRUKTUR-DOKUMENTATION.md

@@ -0,0 +1,149 @@
+# Projektstruktur-Dokumentation
+
+## Übersicht
+
+Diese Dokumentation bietet einen Überblick über die Architektur und Struktur des Projekts. Die Anwendung folgt einer modularen, serviceorientierten Architektur mit klarer Trennung von Verantwortlichkeiten.
+
+## Hauptverzeichnisse
+
+### `/src`
+
+Das Hauptverzeichnis für den Anwendungscode, unterteilt in mehrere Unterverzeichnisse:
+
+#### `/src/Framework`
+
+Enthält das Framework mit grundlegenden Infrastrukturkomponenten:
+
+- **Analytics**: System zur Erfassung und Analyse von Anwendungsdaten
+- **Attributes**: Attribute/Annotations für Metadaten
+- **Cache**: Caching-Mechanismen
+- **CommandBus**: Command-Handling-Komponenten
+- **Config**: Konfigurationsverwaltung
+- **Console**: Konsolenanwendung und -befehle
+- **Core**: Kernkomponenten und Events
+- **DI**: Dependency-Injection-Container
+- **ErrorHandling**: Fehlerbehandlungsmechanismen
+- **EventBus**: Event-Handling-System
+- **Exception**: Framework-Exceptions
+- **Filesystem**: Dateisystemoperationen
+- **Http**: HTTP-Request/Response-Handling
+- **HttpClient**: HTTP-Client für externe API-Aufrufe
+- **Logging**: Logging-Infrastruktur
+- **Performance**: Performance-Monitoring
+- **Queue**: Nachrichtenwarteschlangen
+- **Redis**: Redis-Integration
+- **Router**: URL-Routing
+- **StaticSite**: Statische Site-Generation
+- **Validation**: Datenvalidierung
+- **View**: Template-Rendering
+
+#### `/src/Application`
+
+Anwendungsspezifische Komponenten, die das Framework nutzen.
+
+#### `/src/Domain`
+
+Domain-Modelle, Entities und Business-Logik.
+
+#### `/src/Infrastructure`
+
+Infrastrukturkomponenten, die externe Systeme integrieren.
+
+#### `/src/Config`
+
+Konfigurationsdateien für verschiedene Module.
+
+## Framework-Architektur
+
+### Dependency Injection
+
+Das System nutzt einen leistungsfähigen DI-Container zur Verwaltung von Services:
+
+```php
+#[Initializer]
+class ServiceInitializer
+{
+    public function __invoke(Container $container): Service
+    {
+        // Service erstellen und zurückgeben
+    }
+}
+```
+
+### Event-System
+
+Ein Event-System ermöglicht lose Kopplung zwischen Komponenten:
+
+```php
+$eventDispatcher->addHandler(EventClass::class, function($event) {
+    // Event verarbeiten
+});
+```
+
+### HTTP-Pipeline
+
+HTTP-Requests durchlaufen eine Middleware-Pipeline:
+
+```php
+class CustomMiddleware implements Middleware
+{
+    public function process(Request $request, callable $next): Response
+    {
+        // Request verarbeiten
+        $response = $next($request);
+        // Response verarbeiten
+        return $response;
+    }
+}
+```
+
+## Module und ihre Interaktionen
+
+### Analytics-Modul
+
+Das Analytics-Modul erfasst und analysiert Anwendungsdaten:
+
+- **Events tracken**: `$analytics->track('event_name', $properties)`
+- **HTTP-Tracking**: Automatisch durch `AnalyticsMiddleware`
+- **Error-Tracking**: Integration mit dem Error-Handling-System
+- **Dashboard**: Admin-Interface zur Datenvisualisierung
+
+### Konfigurationssystem
+
+Konfigurationen werden zentral verwaltet und injiziert:
+
+```php
+class Service
+{
+    public function __construct(private Configuration $config)
+    {
+        $settings = $this->config->get('module_name', $defaults);
+    }
+}
+```
+
+## Erweiterbarkeit
+
+### Neue Module hinzufügen
+
+1. Erstellen Sie ein neues Verzeichnis unter `/src/Framework`
+2. Implementieren Sie eine Initializer-Klasse mit dem `#[Initializer]`-Attribut
+3. Erstellen Sie eine entsprechende Konfigurationsdatei unter `/src/Config`
+
+### Middleware hinzufügen
+
+```php
+// In Ihrer Anwendungsklasse
+public function bootstrap(): void
+{
+    $this->addMiddleware(YourMiddleware::class);
+}
+```
+
+## Best Practices
+
+- **Dependency Injection**: Verwenden Sie Constructor-Injection für Abhängigkeiten
+- **Interfaces**: Definieren Sie Interfaces für alle Services
+- **Events**: Nutzen Sie Events für lose Kopplung zwischen Modulen
+- **Konfiguration**: Externalisieren Sie Konfigurationen in dedizierte Dateien
+- **Typsicherheit**: Nutzen Sie strenge Typisierung und readonly-Properties

docs/architecture/index.md

@@ -0,0 +1,70 @@
+# Architektur-Dokumentation
+
+## Übersicht
+
+Diese Dokumentation beschreibt die Architektur und Struktur des Projekts. Sie bietet einen Überblick über die wichtigsten Komponenten, deren Beziehungen und die zugrundeliegenden Architekturprinzipien.
+
+## Inhalte
+
+- [Projektstruktur](/architecture/STRUKTUR-DOKUMENTATION.md) - Überblick über die Struktur des Projekts
+
+## Architekturprinzipien
+
+Das Projekt folgt diesen grundlegenden Architekturprinzipien:
+
+1. **Modulare Architektur**: Klare Trennung von Verantwortlichkeiten in Modulen
+2. **Service-orientiertes Design**: Funktionalitäten als unabhängige Services
+3. **Dependency Injection**: Abhängigkeiten werden explizit injiziert
+4. **Event-basierte Kommunikation**: Lose Kopplung durch Events
+5. **Schichtenarchitektur**: Trennung von Präsentation, Anwendungslogik und Daten
+
+## Hauptkomponenten
+
+### Framework-Kern
+
+Der Framework-Kern stellt grundlegende Infrastrukturkomponenten bereit:
+
+- **DI-Container**: Verwaltung von Service-Abhängigkeiten
+- **Event-System**: Event-basierte Kommunikation
+- **HTTP-Komponenten**: Request/Response-Handling
+- **Routing**: URL-zu-Controller-Mapping
+
+### Anwendungsschicht
+
+Die Anwendungsschicht implementiert die Geschäftslogik:
+
+- **Services**: Implementierung von Anwendungsfunktionen
+- **Commands/Queries**: Command-Query-Separation-Prinzip
+- **Controllers**: HTTP-Request-Handling
+
+### Domainschicht
+
+Die Domainschicht enthält die Kerngeschäftslogik:
+
+- **Entities**: Geschäftsobjekte mit Identität
+- **Value Objects**: Unveränderliche Wertobjekte
+- **Domain Services**: Domänenspezifische Logik
+
+### Infrastrukturschicht
+
+Die Infrastrukturschicht bietet technische Funktionen:
+
+- **Persistenz**: Datenbankzugriff und -verwaltung
+- **Messaging**: Externe Kommunikation
+- **Integration**: Anbindung an externe Systeme
+
+## Datenfluss
+
+Ein typischer Datenfluss im System:
+
+1. HTTP-Request wird vom Router empfangen
+2. Middleware-Pipeline verarbeitet den Request
+3. Controller erhält den Request und delegiert an Services
+4. Services implementieren die Geschäftslogik
+5. Domain-Objekte repräsentieren den Geschäftszustand
+6. Repositories speichern/laden Daten
+7. Response wird erstellt und zurückgegeben
+
+## Weitere Informationen
+
+Für detailliertere Informationen zur Architektur siehe die [Projektstruktur-Dokumentation](/architecture/STRUKTUR-DOKUMENTATION.md).