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/docs/getting-started/configuration.md
+++ b/docs/getting-started/configuration.md
@@ -0,0 +1,214 @@
+# Konfiguration
+
+Diese Anleitung erklärt, wie Sie das Framework nach der Installation konfigurieren können.
+
+## Umgebungsvariablen
+
+Die Hauptkonfiguration des Frameworks erfolgt über Umgebungsvariablen, die in der `.env`-Datei definiert sind. Wenn Sie das Framework gerade installiert haben, sollten Sie eine Kopie der `.env.example`-Datei erstellt und in `.env` umbenannt haben.
+
+### Wichtige Umgebungsvariablen
+
+Hier sind die wichtigsten Umgebungsvariablen, die Sie konfigurieren sollten:
+
+#### Anwendung
+
+```
+APP_NAME="Meine Anwendung"
+APP_ENV=development
+APP_DEBUG=true
+APP_URL=http://localhost:8000
+APP_KEY=base64:...
+```
+
+- `APP_NAME`: Der Name Ihrer Anwendung
+- `APP_ENV`: Die Umgebung, in der die Anwendung läuft (`development`, `testing` oder `production`)
+- `APP_DEBUG`: Ob Debug-Informationen angezeigt werden sollen (`true` oder `false`)
+- `APP_URL`: Die Basis-URL Ihrer Anwendung
+- `APP_KEY`: Der Verschlüsselungsschlüssel für Ihre Anwendung (wird automatisch generiert)
+
+#### Datenbank
+
+```
+DB_CONNECTION=mysql
+DB_HOST=127.0.0.1
+DB_PORT=3306
+DB_DATABASE=framework
+DB_USERNAME=root
+DB_PASSWORD=
+```
+
+- `DB_CONNECTION`: Der Datenbanktyp (`mysql`, `sqlite`, `pgsql` oder `sqlsrv`)
+- `DB_HOST`: Der Hostname des Datenbankservers
+- `DB_PORT`: Der Port des Datenbankservers
+- `DB_DATABASE`: Der Name der Datenbank
+- `DB_USERNAME`: Der Benutzername für die Datenbankverbindung
+- `DB_PASSWORD`: Das Passwort für die Datenbankverbindung
+
+#### Cache und Sitzungen
+
+```
+CACHE_DRIVER=file
+SESSION_DRIVER=file
+SESSION_LIFETIME=120
+```
+
+- `CACHE_DRIVER`: Der Cache-Treiber (`file`, `redis` oder `memory`)
+- `SESSION_DRIVER`: Der Sitzungstreiber (`file`, `database` oder `redis`)
+- `SESSION_LIFETIME`: Die Lebensdauer der Sitzung in Minuten
+
+#### E-Mail
+
+```
+MAIL_DRIVER=smtp
+MAIL_HOST=smtp.mailtrap.io
+MAIL_PORT=2525
+MAIL_USERNAME=null
+MAIL_PASSWORD=null
+MAIL_ENCRYPTION=null
+MAIL_FROM_ADDRESS=null
+MAIL_FROM_NAME="${APP_NAME}"
+```
+
+- `MAIL_DRIVER`: Der E-Mail-Treiber (`smtp`, `sendmail` oder `log`)
+- `MAIL_HOST`: Der Hostname des SMTP-Servers
+- `MAIL_PORT`: Der Port des SMTP-Servers
+- `MAIL_USERNAME`: Der Benutzername für die SMTP-Verbindung
+- `MAIL_PASSWORD`: Das Passwort für die SMTP-Verbindung
+- `MAIL_ENCRYPTION`: Die Verschlüsselungsmethode (`tls` oder `ssl`)
+- `MAIL_FROM_ADDRESS`: Die Absenderadresse
+- `MAIL_FROM_NAME`: Der Absendername
+
+## Konfigurationsdateien
+
+Neben den Umgebungsvariablen verwendet das Framework auch Konfigurationsdateien im Verzeichnis `config/`. Diese Dateien enthalten Konfigurationen, die nicht über Umgebungsvariablen gesteuert werden sollten oder komplexere Strukturen erfordern.
+
+### Wichtige Konfigurationsdateien
+
+#### app.php
+
+Die Datei `config/app.php` enthält allgemeine Anwendungskonfigurationen:
+
+```php
+return [
+    'name' => env('APP_NAME', 'Framework'),
+    'env' => env('APP_ENV', 'production'),
+    'debug' => env('APP_DEBUG', false),
+    'url' => env('APP_URL', 'http://localhost'),
+    'timezone' => 'UTC',
+    'locale' => 'de',
+    'fallback_locale' => 'en',
+    'key' => env('APP_KEY'),
+    'cipher' => 'AES-256-CBC',
+    'providers' => [
+        // Service-Provider
+    ],
+    'aliases' => [
+        // Fassaden
+    ],
+];
+```
+
+#### database.php
+
+Die Datei `config/database.php` enthält Datenbankkonfigurationen:
+
+```php
+return [
+    'default' => env('DB_CONNECTION', 'mysql'),
+    'connections' => [
+        'sqlite' => [
+            'driver' => 'sqlite',
+            'database' => env('DB_DATABASE', database_path('database.sqlite')),
+            'prefix' => '',
+        ],
+        'mysql' => [
+            'driver' => 'mysql',
+            'host' => env('DB_HOST', '127.0.0.1'),
+            'port' => env('DB_PORT', '3306'),
+            'database' => env('DB_DATABASE', 'forge'),
+            'username' => env('DB_USERNAME', 'forge'),
+            'password' => env('DB_PASSWORD', ''),
+            'charset' => 'utf8mb4',
+            'collation' => 'utf8mb4_unicode_ci',
+            'prefix' => '',
+            'strict' => true,
+            'engine' => null,
+        ],
+        // Weitere Datenbankverbindungen
+    ],
+    'migrations' => 'migrations',
+    'redis' => [
+        'client' => 'predis',
+        'default' => [
+            'host' => env('REDIS_HOST', '127.0.0.1'),
+            'password' => env('REDIS_PASSWORD', null),
+            'port' => env('REDIS_PORT', 6379),
+            'database' => 0,
+        ],
+    ],
+];
+```
+
+#### cache.php
+
+Die Datei `config/cache.php` enthält Cache-Konfigurationen:
+
+```php
+return [
+    'default' => env('CACHE_DRIVER', 'file'),
+    'stores' => [
+        'file' => [
+            'driver' => 'file',
+            'path' => storage_path('framework/cache'),
+        ],
+        'redis' => [
+            'driver' => 'redis',
+            'connection' => 'default',
+        ],
+        'memory' => [
+            'driver' => 'memory',
+        ],
+    ],
+    'prefix' => env('CACHE_PREFIX', 'framework_cache'),
+];
+```
+
+## Benutzerdefinierte Konfiguration
+
+Sie können auch eigene Konfigurationsdateien erstellen, um anwendungsspezifische Einstellungen zu speichern. Erstellen Sie dazu eine neue Datei im Verzeichnis `config/` und geben Sie ein Array zurück:
+
+```php
+// config/myapp.php
+return [
+    'feature_flags' => [
+        'new_ui' => env('FEATURE_NEW_UI', false),
+        'api_v2' => env('FEATURE_API_V2', false),
+    ],
+    'limits' => [
+        'max_items' => 100,
+        'max_file_size' => 10 * 1024 * 1024, // 10 MB
+    ],
+];
+```
+
+Sie können dann auf diese Konfiguration zugreifen mit:
+
+```php
+$newUiEnabled = config('myapp.feature_flags.new_ui');
+$maxItems = config('myapp.limits.max_items');
+```
+
+## Umgebungsspezifische Konfiguration
+
+Das Framework unterstützt umgebungsspezifische Konfigurationen. Sie können verschiedene `.env`-Dateien für verschiedene Umgebungen erstellen:
+
+- `.env` - Standardkonfiguration
+- `.env.development` - Entwicklungsumgebung
+- `.env.testing` - Testumgebung
+- `.env.production` - Produktionsumgebung
+
+Um eine bestimmte Umgebungskonfiguration zu laden, setzen Sie die Umgebungsvariable `APP_ENV` auf den entsprechenden Wert.
+
+## Nächste Schritte
+
+Nachdem Sie das Framework konfiguriert haben, können Sie mit den [ersten Schritten](first-steps.md) fortfahren, um Ihre erste Anwendung zu erstellen.
--- a/docs/getting-started/first-steps.md
+++ b/docs/getting-started/first-steps.md
@@ -0,0 +1,327 @@
+# Erste Schritte
+
+Diese Anleitung führt Sie durch die ersten Schritte mit dem Framework, nachdem Sie es [installiert](installation.md) und [konfiguriert](configuration.md) haben.
+
+## Projektstruktur
+
+Zunächst sollten Sie sich mit der Projektstruktur vertraut machen:
+
+```
+my-project/
+├── bin/                  # Ausführbare Skripte
+├── config/               # Konfigurationsdateien
+├── docs/                 # Dokumentation
+├── public/               # Öffentlich zugängliche Dateien
+│   ├── index.php         # Einstiegspunkt für die Anwendung
+│   ├── assets/           # Kompilierte Assets (CSS, JS)
+│   └── uploads/          # Hochgeladene Dateien
+├── resources/            # Quellressourcen
+│   ├── css/              # CSS-Dateien
+│   ├── js/               # JavaScript-Dateien
+│   └── views/            # Template-Dateien
+├── src/                  # PHP-Quellcode
+│   ├── Application/      # Anwendungsspezifischer Code
+│   │   ├── Controllers/  # Controller
+│   │   ├── Models/       # Modelle
+│   │   └── Services/     # Services
+│   └── Framework/        # Framework-Code
+│       ├── Core/         # Kernkomponenten
+│       ├── Database/     # Datenbankabstraktion
+│       └── Http/         # HTTP-Komponenten
+├── storage/              # Speicher für Anwendungsdaten
+│   ├── cache/            # Cache-Dateien
+│   ├── logs/             # Log-Dateien
+│   └── uploads/          # Hochgeladene Dateien
+├── tests/                # Testdateien
+├── vendor/               # Composer-Abhängigkeiten
+├── .env                  # Umgebungsvariablen
+├── composer.json         # Composer-Konfiguration
+├── console.php           # Kommandozeilen-Interface
+└── README.md             # Projektdokumentation
+```
+
+## Erstellen einer einfachen Seite
+
+Lassen Sie uns eine einfache Seite erstellen, um zu sehen, wie das Framework funktioniert.
+
+### 1. Erstellen eines Controllers
+
+Erstellen Sie eine neue Datei `src/Application/Controllers/WelcomeController.php`:
+
+```php
+<?php
+
+namespace App\Application\Controllers;
+
+use App\Framework\Http\Controller;
+use App\Framework\Http\Request;
+use App\Framework\Http\Response;
+
+class WelcomeController extends Controller
+{
+    public function index(Request $request): Response
+    {
+        return $this->view('welcome', [
+            'title' => 'Willkommen',
+            'message' => 'Willkommen beim Framework!',
+        ]);
+    }
+}
+```
+
+### 2. Erstellen einer View
+
+Erstellen Sie eine neue Datei `resources/views/welcome.php`:
+
+```php
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><?= $title ?></title>
+    <link rel="stylesheet" href="/assets/css/app.css">
+</head>
+<body>
+    <div class="container">
+        <h1><?= $title ?></h1>
+        <p><?= $message ?></p>
+    </div>
+    <script src="/assets/js/app.js"></script>
+</body>
+</html>
+```
+
+### 3. Definieren einer Route
+
+Öffnen Sie die Datei `config/routes.php` und fügen Sie eine neue Route hinzu:
+
+```php
+<?php
+
+use App\Application\Controllers\WelcomeController;
+use App\Framework\Routing\Router;
+
+return function (Router $router) {
+    $router->get('/', [WelcomeController::class, 'index']);
+};
+```
+
+### 4. Testen der Anwendung
+
+Starten Sie den eingebauten Entwicklungsserver:
+
+```bash
+php console.php serve
+```
+
+Öffnen Sie dann Ihren Browser und navigieren Sie zu `http://localhost:8000`. Sie sollten Ihre neue Seite sehen.
+
+## Erstellen einer API-Endpunkt
+
+Lassen Sie uns einen einfachen API-Endpunkt erstellen.
+
+### 1. Erstellen eines API-Controllers
+
+Erstellen Sie eine neue Datei `src/Application/Controllers/Api/UserController.php`:
+
+```php
+<?php
+
+namespace App\Application\Controllers\Api;
+
+use App\Framework\Http\Controller;
+use App\Framework\Http\Request;
+use App\Framework\Http\Response;
+
+class UserController extends Controller
+{
+    public function index(Request $request): Response
+    {
+        $users = [
+            ['id' => 1, 'name' => 'Max Mustermann'],
+            ['id' => 2, 'name' => 'Erika Musterfrau'],
+        ];
+
+        return $this->json($users);
+    }
+
+    public function show(Request $request, int $id): Response
+    {
+        $users = [
+            1 => ['id' => 1, 'name' => 'Max Mustermann'],
+            2 => ['id' => 2, 'name' => 'Erika Musterfrau'],
+        ];
+
+        if (!isset($users[$id])) {
+            return $this->json(['error' => 'Benutzer nicht gefunden'], 404);
+        }
+
+        return $this->json($users[$id]);
+    }
+}
+```
+
+### 2. Definieren von API-Routen
+
+Fügen Sie in der Datei `config/routes.php` die folgenden Routen hinzu:
+
+```php
+$router->group('/api', function (Router $router) {
+    $router->get('/users', [UserController::class, 'index']);
+    $router->get('/users/{id}', [UserController::class, 'show']);
+});
+```
+
+Vergessen Sie nicht, den Controller zu importieren:
+
+```php
+use App\Application\Controllers\Api\UserController;
+```
+
+### 3. Testen der API
+
+Starten Sie den Entwicklungsserver und testen Sie die API mit einem HTTP-Client wie curl:
+
+```bash
+curl http://localhost:8000/api/users
+curl http://localhost:8000/api/users/1
+```
+
+## Arbeiten mit der Datenbank
+
+Das Framework bietet eine einfache Datenbankabstraktion. Hier ist ein Beispiel für die Arbeit mit der Datenbank:
+
+### 1. Erstellen eines Modells
+
+Erstellen Sie eine neue Datei `src/Application/Models/User.php`:
+
+```php
+<?php
+
+namespace App\Application\Models;
+
+use App\Framework\Database\Model;
+
+class User extends Model
+{
+    protected string $table = 'users';
+    protected array $fillable = ['name', 'email', 'password'];
+    protected array $hidden = ['password'];
+}
+```
+
+### 2. Erstellen einer Migration
+
+Erstellen Sie eine neue Migration mit dem Konsolenbefehl:
+
+```bash
+php console.php db:migration:create create_users_table
+```
+
+Dies erstellt eine neue Datei in `migrations/`. Bearbeiten Sie die Datei:
+
+```php
+<?php
+
+use App\Framework\Database\Migration;
+use App\Framework\Database\Schema\Blueprint;
+
+class CreateUsersTable extends Migration
+{
+    public function up(): void
+    {
+        $this->schema->create('users', function (Blueprint $table) {
+            $table->id();
+            $table->string('name');
+            $table->string('email')->unique();
+            $table->string('password');
+            $table->timestamps();
+        });
+    }
+
+    public function down(): void
+    {
+        $this->schema->dropIfExists('users');
+    }
+}
+```
+
+### 3. Ausführen der Migration
+
+Führen Sie die Migration aus:
+
+```bash
+php console.php db:migrate
+```
+
+### 4. Verwenden des Modells im Controller
+
+Aktualisieren Sie den `UserController`:
+
+```php
+<?php
+
+namespace App\Application\Controllers\Api;
+
+use App\Application\Models\User;
+use App\Framework\Http\Controller;
+use App\Framework\Http\Request;
+use App\Framework\Http\Response;
+
+class UserController extends Controller
+{
+    public function index(Request $request): Response
+    {
+        $users = User::all();
+        return $this->json($users);
+    }
+
+    public function show(Request $request, int $id): Response
+    {
+        $user = User::find($id);
+
+        if (!$user) {
+            return $this->json(['error' => 'Benutzer nicht gefunden'], 404);
+        }
+
+        return $this->json($user);
+    }
+
+    public function store(Request $request): Response
+    {
+        $this->validate($request, [
+            'name' => 'required|string|max:255',
+            'email' => 'required|email|unique:users,email',
+            'password' => 'required|string|min:8',
+        ]);
+
+        $user = User::create([
+            'name' => $request->input('name'),
+            'email' => $request->input('email'),
+            'password' => password_hash($request->input('password'), PASSWORD_DEFAULT),
+        ]);
+
+        return $this->json($user, 201);
+    }
+}
+```
+
+Fügen Sie eine neue Route hinzu:
+
+```php
+$router->post('/api/users', [UserController::class, 'store']);
+```
+
+## Nächste Schritte
+
+Nachdem Sie die Grundlagen des Frameworks kennengelernt haben, können Sie sich mit den folgenden Themen befassen:
+
+- [Routing](../guides/routing.md) - Erfahren Sie mehr über das Routing-System
+- [Controller](../guides/controllers.md) - Lernen Sie, wie Sie Controller effektiv einsetzen
+- [Validierung](../guides/validation.md) - Validieren Sie Benutzereingaben
+- [Datenbank](../guides/database.md) - Arbeiten Sie mit der Datenbank
+- [Authentifizierung](../guides/authentication.md) - Implementieren Sie Benutzerauthentifizierung
+- [Sicherheit](../guides/security.md) - Schützen Sie Ihre Anwendung
+
+Oder erkunden Sie die [Komponenten](../components/README.md) des Frameworks, um mehr über die verfügbaren Funktionen zu erfahren.
--- a/docs/getting-started/installation.md
+++ b/docs/getting-started/installation.md
@@ -0,0 +1,108 @@
+# Installation
+
+Diese Anleitung führt Sie durch den Installationsprozess des Frameworks.
+
+## Systemanforderungen
+
+Bevor Sie mit der Installation beginnen, stellen Sie sicher, dass Ihr System die folgenden Anforderungen erfüllt:
+
+- PHP 8.1 oder höher
+- Composer 2.0 oder höher
+- Node.js 16 oder höher (für Frontend-Assets)
+- MySQL 8.0 oder höher (optional, wenn Sie MySQL als Datenbank verwenden)
+- SQLite 3 (für Entwicklung und Tests)
+
+## Installation über Composer
+
+Die einfachste Methode zur Installation ist über Composer:
+
+```bash
+composer create-project michaelschiemer/framework my-project
+cd my-project
+```
+
+## Manuelle Installation
+
+Alternativ können Sie das Framework auch manuell installieren:
+
+1. Klonen Sie das Repository:
+
+```bash
+git clone https://github.com/michaelschiemer/framework.git my-project
+cd my-project
+```
+
+2. Installieren Sie die Abhängigkeiten:
+
+```bash
+composer install
+npm install
+```
+
+## Konfiguration nach der Installation
+
+Nach der Installation müssen Sie einige grundlegende Konfigurationen vornehmen:
+
+1. Erstellen Sie eine Kopie der `.env.example`-Datei und benennen Sie sie in `.env` um:
+
+```bash
+cp .env.example .env
+```
+
+2. Generieren Sie einen Anwendungsschlüssel:
+
+```bash
+php console.php app:key-generate
+```
+
+3. Konfigurieren Sie Ihre Datenbankverbindung in der `.env`-Datei.
+
+4. Führen Sie die Migrationen aus:
+
+```bash
+php console.php db:migrate
+```
+
+## Überprüfung der Installation
+
+Um zu überprüfen, ob die Installation erfolgreich war, können Sie den eingebauten Entwicklungsserver starten:
+
+```bash
+php console.php serve
+```
+
+Öffnen Sie dann Ihren Browser und navigieren Sie zu `http://localhost:8000`. Sie sollten die Startseite des Frameworks sehen.
+
+## Fehlerbehebung
+
+### Häufige Probleme
+
+#### Composer-Fehler
+
+Wenn Sie Probleme mit Composer haben, versuchen Sie, den Cache zu leeren:
+
+```bash
+composer clear-cache
+```
+
+#### Berechtigungsprobleme
+
+Stellen Sie sicher, dass die folgenden Verzeichnisse für den Webserver beschreibbar sind:
+
+- `storage/`
+- `cache/`
+- `logs/`
+
+Sie können die Berechtigungen mit dem folgenden Befehl ändern:
+
+```bash
+chmod -R 775 storage cache logs
+```
+
+#### Datenbank-Verbindungsprobleme
+
+Überprüfen Sie Ihre Datenbankverbindungseinstellungen in der `.env`-Datei. Stellen Sie sicher, dass der Datenbankbenutzer die richtigen Berechtigungen hat.
+
+## Nächste Schritte
+
+Nachdem Sie das Framework erfolgreich installiert haben, können Sie mit der [Konfiguration](configuration.md) fortfahren und dann die [ersten Schritte](first-steps.md) unternehmen, um Ihre erste Anwendung zu erstellen.