Enable Discovery debug logging for production troubleshooting

- Add DISCOVERY_LOG_LEVEL=debug - Add DISCOVERY_SHOW_PROGRESS=true - Temporary changes for debugging InitializerProcessor fixes on production
2025-08-11 20:13:26 +02:00
parent 59fd3dd3b1
commit 55a330b223
3683 changed files with 2956207 additions and 16948 deletions
--- a/backups/docs-backup-20250731125004/standards/CODING-GUIDELINES.md
+++ b/backups/docs-backup-20250731125004/standards/CODING-GUIDELINES.md
@@ -0,0 +1,234 @@
+# Coding Guidelines
+
+## Allgemeine Prinzipien
+
+Diese Guidelines definieren die Standards für die Entwicklung und Wartung des Projekts. Sie sorgen für Konsistenz, Lesbarkeit und Wartbarkeit des Codes.
+
+## PHP-Version
+
+- **PHP 8.4**: Die Codebase nutzt stets die neueste stabile PHP-Version (aktuell PHP 8.4)
+- Alle neuen PHP-Sprachfeatures sollten, wo sinnvoll, genutzt werden
+
+## Abhängigkeiten
+
+- **Externe Abhängigkeiten vermeiden**: Das Projekt soll möglichst ohne externe Bibliotheken auskommen
+- **Eigene Implementierungen bevorzugen**: Anstatt externe Pakete einzubinden, sollten eigene Lösungen entwickelt werden
+- **Erlaubte Abhängigkeiten**: Nur die bereits in composer.json definierten Pakete dürfen verwendet werden
+- **Neue Abhängigkeiten**: Müssen explizit genehmigt werden und sollten nur in Ausnahmefällen hinzugefügt werden
+
+## Klassenstruktur
+
+### Klassen
+
+- **Alle Klassen müssen `final` sein**, es sei denn, es gibt einen zwingenden Grund für Vererbung
+- **Keine abstrakten Klassen** - bevorzuge Interfaces und Kompositionen
+- **Klassen sollten `readonly` sein**, wann immer möglich
+- Interfaces verwenden, um Verträge zwischen Komponenten zu definieren
+
+```php
+// Gut
+final readonly class AnalyticsManager
+{
+    // ...
+}
+
+// Vermeiden
+abstract class BaseManager
+{
+    // ...
+}
+```
+
+### Properties
+
+- **Properties sollten `readonly` sein**, wann immer möglich
+- Private Visibility für alle Properties, es sei denn, es gibt einen zwingenden Grund
+- Typisierung ist obligatorisch für alle Properties
+
+```php
+// Gut
+private readonly StorageInterface $storage;
+
+// Vermeiden
+public array $config;
+```
+
+## Methoden und Funktionen
+
+- Typisierung ist obligatorisch für alle Parameter und Rückgabewerte
+- Methoden sollten klein und fokussiert sein (Single Responsibility)
+- Verwende named arguments für bessere Lesbarkeit
+
+```php
+// Gut
+public function track(string $event, array $properties = [], ?string $userId = null): void
+{
+    // ...
+}
+
+// Vermeiden
+public function process($data)
+{
+    // ...
+}
+```
+
+## Dependency Injection
+
+- Constructor Injection für alle Abhängigkeiten
+- Keine Service Locator oder globale Zustände
+- Verwende das `#[Initializer]`-Attribut für Service-Registrierung
+
+```php
+// Gut
+public function __construct(
+    private readonly Configuration $config,
+    private readonly StorageInterface $storage
+) {}
+
+// Vermeiden
+public function __construct()
+{
+    $this->config = Container::get(Configuration::class);
+}
+```
+
+## Moderne PHP-Features
+
+### Nullable Types und Union Types
+
+```php
+public function findUser(?int $id): ?User
+public function process(int|string $identifier): void
+```
+
+### Match Expression statt Switch
+
+```php
+// Gut
+return match($storageType) {
+    'file' => new FileStorage($path),
+    'redis' => new RedisStorage($connection),
+    default => throw new \InvalidArgumentException("Nicht unterstützter Storage-Typ: {$storageType}")
+};
+
+// Vermeiden
+switch ($storageType) {
+    case 'file':
+        return new FileStorage($path);
+    // ...
+}
+```
+
+### Named Arguments
+
+```php
+$this->createUser(
+    email: 'user@example.com',
+    role: 'admin',
+    sendWelcomeEmail: true
+);
+```
+
+### Constructor Property Promotion
+
+```php
+public function __construct(
+    private readonly Configuration $config,
+    private readonly PathProvider $pathProvider
+) {}
+```
+
+## Fehlerbehandlung
+
+- Spezifische Exceptions werfen
+- Typed Exceptions verwenden
+- Early Return Pattern bevorzugen
+
+```php
+// Gut
+if (!$this->isValid()) {
+    throw new ValidationException('Ungültige Daten');
+}
+
+// Vermeiden
+if ($this->isValid()) {
+    // Lange Verarbeitung...
+} else {
+    throw new Exception('Fehler');
+}
+```
+
+## Testing
+
+- Tests mit Pest-Framework schreiben
+- Für jede öffentliche Methode sollte mindestens ein Test existieren
+- Mocking nur für externe Abhängigkeiten verwenden
+
+```php
+test('track method records events correctly', function () {
+    $analytics = new Analytics($manager, $dispatcher);
+    $analytics->track('test_event', ['key' => 'value']);
+
+    expect($manager->getEvents())->toHaveCount(1);
+});
+```
+
+## Dokumentation
+
+- PHPDoc für alle öffentlichen Methoden und Klassen
+- Typen in PHPDoc sollten den tatsächlichen Typen entsprechen
+- Klare, beschreibende Kommentare für komplexe Logik
+
+```php
+/**
+ * Zeichnet ein Event auf und wendet Middleware an
+ *
+ * @param string $event Event-Name
+ * @param array $properties Event-Eigenschaften
+ * @param string|null $userId Benutzer-ID (optional)
+ */
+public function track(string $event, array $properties = [], ?string $userId = null): void
+```
+
+## Namenskonventionen
+
+- **Klassen**: PascalCase (`AnalyticsManager`)
+- **Methoden/Funktionen**: camelCase (`getEventStats()`)
+- **Variablen**: camelCase (`$eventData`)
+- **Konstanten**: SNAKE_CASE (`MAX_BATCH_SIZE`)
+- **Dateien**: Klassenname.php (`AnalyticsManager.php`)
+
+## Architektur
+
+- Dependency Inversion Principle befolgen
+- Interfaces für alle externen Abhängigkeiten
+- Vermeide zirkuläre Abhängigkeiten zwischen Modulen
+- Services sollten eine klare, fokussierte Verantwortung haben
+
+## Performance
+
+- Lazy Loading für ressourcenintensive Operationen
+- Caching wo sinnvoll
+- Datenstrukturen sorgfältig auswählen
+
+## Security
+
+- Alle Benutzereingaben validieren und bereinigen
+- Prepared Statements für Datenbankabfragen
+- Vermeidung von `eval()` und ähnlichen unsicheren Funktionen
+- Sensible Daten niemals in Logs schreiben
+
+## Best Practices
+
+- **Immutability**: Bevorzuge unveränderliche Objekte
+- **Pure Functions**: Bevorzuge reine Funktionen ohne Seiteneffekte
+- **Enums**: Verwende Enums statt String-Konstanten für feste Optionssätze
+- **DTOs**: Verwende Data Transfer Objects für Datentransport
+- **Value Objects**: Verwende Value Objects für semantisch reiche Datentypen
+
+## Refactoring
+
+- Code, der diese Guidelines nicht erfüllt, sollte beim Bearbeiten aktualisiert werden
+- Tests müssen vor und nach dem Refactoring bestehen
+- Große Refactorings sollten in kleinen, separaten Commits erfolgen
--- a/backups/docs-backup-20250731125004/standards/SICHERHEITS-GUIDELINES.md
+++ b/backups/docs-backup-20250731125004/standards/SICHERHEITS-GUIDELINES.md
@@ -0,0 +1,187 @@
+# Sicherheitsrichtlinien
+
+## Übersicht
+
+Diese Richtlinien definieren Standards und Best Practices für sichere Softwareentwicklung im Projekt.
+
+## Grundprinzipien
+
+### 1. Defense in Depth
+
+- Mehrere Sicherheitsschichten implementieren
+- Nicht auf eine einzelne Sicherheitsmaßnahme vertrauen
+- Fail-Safe-Mechanismen einbauen
+
+### 2. Least Privilege
+
+- Minimale Berechtigungen für Funktionen und Benutzer
+- Ressourcenzugriff nur bei Bedarf gewähren
+- Temporäre Berechtigungen nach Gebrauch entziehen
+
+### 3. Input-Validierung
+
+- Alle Benutzereingaben validieren und bereinigen
+- Whitelist-Ansatz bevorzugen (erlaubte Eingaben definieren)
+- Typprüfung und Formatvalidierung durchführen
+
+```php
+// Beispiel: Sichere Input-Validierung
+public function processUserInput(string $input): string
+{
+    // Länge prüfen
+    if (strlen($input) > 100) {
+        throw new ValidationException('Input zu lang (max 100 Zeichen)');
+    }
+
+    // Inhalt validieren (Whitelist-Ansatz)
+    if (!preg_match('/^[a-zA-Z0-9\s\-_]+$/', $input)) {
+        throw new ValidationException('Input enthält ungültige Zeichen');
+    }
+
+    // Bereinigung
+    return htmlspecialchars($input, ENT_QUOTES, 'UTF-8');
+}
+```
+
+## Spezifische Sicherheitsmaßnahmen
+
+### 1. SQL-Injection-Prävention
+
+- Prepared Statements für alle Datenbankabfragen
+- Keine dynamischen SQL-Queries
+- ORM-Framework bevorzugen
+
+```php
+// Sicher
+$stmt = $pdo->prepare("SELECT * FROM users WHERE email = ?");
+$stmt->execute([$email]);
+
+// Unsicher - NIEMALS SO MACHEN
+$query = "SELECT * FROM users WHERE email = '{$email}'";
+```
+
+### 2. Cross-Site Scripting (XSS) Prävention
+
+- Output-Escaping für alle benutzergenerierten Inhalte
+- Content-Security-Policy (CSP) implementieren
+- HttpOnly und Secure Flags für Cookies
+
+```php
+// Ausgabe in HTML
+echo htmlspecialchars($userInput, ENT_QUOTES, 'UTF-8');
+
+// Ausgabe in JavaScript
+echo json_encode($userInput, JSON_HEX_TAG | JSON_HEX_APOS | JSON_HEX_QUOT | JSON_HEX_AMP);
+```
+
+### 3. Cross-Site Request Forgery (CSRF) Schutz
+
+- CSRF-Token für alle ändernden Anfragen
+- SameSite-Attribut für Cookies
+
+```php
+// CSRF-Token generieren
+public function generateCsrfToken(): string
+{
+    $token = bin2hex(random_bytes(32));
+    $_SESSION['csrf_token'] = $token;
+    return $token;
+}
+
+// CSRF-Token validieren
+public function validateCsrfToken(string $token): bool
+{
+    return hash_equals($_SESSION['csrf_token'] ?? '', $token);
+}
+```
+
+### 4. Sichere Authentifizierung
+
+- Passwörter mit starken Algorithmen hashen (Argon2id)
+- Multi-Faktor-Authentifizierung anbieten
+- Ratelimiting für Login-Versuche
+
+```php
+// Passwort hashen
+public function hashPassword(string $password): string
+{
+    return password_hash($password, PASSWORD_ARGON2ID);
+}
+
+// Passwort verifizieren
+public function verifyPassword(string $password, string $hash): bool
+{
+    return password_verify($password, $hash);
+}
+```
+
+### 5. Sichere Datenspeicherung
+
+- Sensible Daten verschlüsseln
+- Separate Schlüssel für unterschiedliche Daten
+- Schlüsselrotation implementieren
+
+```php
+// Daten verschlüsseln
+public function encrypt(string $data, string $purpose): string
+{
+    $key = $this->getEncryptionKey($purpose);
+    $nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
+
+    $cipher = sodium_crypto_secretbox(
+        $data,
+        $nonce,
+        $key
+    );
+
+    return base64_encode($nonce . $cipher);
+}
+
+// Daten entschlüsseln
+public function decrypt(string $encrypted, string $purpose): string
+{
+    $key = $this->getEncryptionKey($purpose);
+    $decoded = base64_decode($encrypted);
+
+    $nonce = mb_substr($decoded, 0, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, '8bit');
+    $cipher = mb_substr($decoded, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, null, '8bit');
+
+    return sodium_crypto_secretbox_open(
+        $cipher,
+        $nonce,
+        $key
+    );
+}
+```
+
+## Sicherheitstests
+
+### 1. Automatisierte Sicherheitstests
+
+- Static Application Security Testing (SAST)
+- Dynamic Application Security Testing (DAST)
+- Dependency-Scanning für bekannte Schwachstellen
+
+### 2. Penetrationstests
+
+- Regelmäßige Sicherheitsaudits
+- Manuelle Penetrationstests
+- Bug-Bounty-Programme
+
+## Sicherheitskultur
+
+### 1. Entwicklerschulungen
+
+- Regelmäßige Sicherheitsschulungen
+- Code-Reviews mit Sicherheitsfokus
+- Sicherheits-Champions im Team
+
+### 2. Incident Response
+
+- Sicherheitsvorfälle dokumentieren
+- Prozess für Sicherheitsmeldungen
+- Notfallpläne für Sicherheitsvorfälle
+
+## Zusammenfassung
+
+Sicherheit ist ein kontinuierlicher Prozess, keine einmalige Aufgabe. Diese Richtlinien sollten regelmäßig überprüft und aktualisiert werden, um neuen Bedrohungen zu begegnen.
--- a/backups/docs-backup-20250731125004/standards/index.md
+++ b/backups/docs-backup-20250731125004/standards/index.md
@@ -0,0 +1,50 @@
+# Coding-Standards und Richtlinien
+
+## Übersicht
+
+Diese Standards und Richtlinien definieren die grundlegenden Prinzipien für die Codierung und Sicherheit im Projekt. Sie gewährleisten Konsistenz, Wartbarkeit und Sicherheit des Codes.
+
+## Verfügbare Standards
+
+- [Coding Guidelines](/standards/CODING-GUIDELINES.md) - Allgemeine Coding-Standards für das Projekt
+- [Sicherheitsrichtlinien](/standards/SICHERHEITS-GUIDELINES.md) - Standards für sichere Softwareentwicklung
+
+## Coding Guidelines
+
+Die [Coding Guidelines](/standards/CODING-GUIDELINES.md) definieren die technischen Standards für die Codeentwicklung, einschließlich:
+
+- Klassenstruktur und -design
+- Property- und Methodendefinitionen
+- Nutzung moderner PHP-Features
+- Fehlerbehandlung
+- Dokumentation
+- Namenskonventionen
+
+## Sicherheitsrichtlinien
+
+Die [Sicherheitsrichtlinien](/standards/SICHERHEITS-GUIDELINES.md) bieten umfassende Anleitungen zur sicheren Softwareentwicklung:
+
+- Input-Validierung
+- SQL-Injection-Prävention
+- XSS-Schutz
+- CSRF-Schutz
+- Sichere Authentifizierung
+- Sichere Datenspeicherung
+- Session-Management
+
+## Anwendung der Standards
+
+Alle Teammitglieder sind verpflichtet, diese Standards in ihrer Arbeit anzuwenden. Sie dienen als Grundlage für Code-Reviews und Qualitätssicherung.
+
+## Abweichungen von Standards
+
+In Ausnahmefällen können Abweichungen von diesen Standards erforderlich sein. Solche Abweichungen sollten:
+
+1. Dokumentiert werden
+2. Begründet werden
+3. Im Team besprochen werden
+4. Auf ein Minimum beschränkt werden
+
+## Aktualisierungen
+
+Diese Standards werden regelmäßig überprüft und aktualisiert, um sicherzustellen, dass sie den neuesten Best Practices und Technologien entsprechen.