Votre MVP commence ici.

CoreEngine utilise un chargeur d'environnement personnalisé pour isoler vos paramètres sensibles. Le fichier .env est automatiquement parsé et typé pour faciliter son utilisation dans votre code.

// Récupération avec valeur par défaut
$debug = env('APP_DEBUG', false); 

// Le helper transforme les strings du .env :
// "true"  => true  (bool)
// "false" => false (bool)
// "null"  => null  (null)
                        

Le framework repose sur une arborescence stricte séparant le code métier de la mécanique interne, avec une gestion hybride de l'autoloading (Natif + Composer optionnel).

// config/app.php
'providers' => [
    \App\Providers\DatabaseServiceProvider::class,
    \App\Providers\AuthServiceProvider::class,
]
                    

CoreEngine est conçu pour fonctionner de manière 100% autonome, sans nécessiter Composer. Cependant, il est assez flexible pour s'intégrer avec si vous souhaitez utiliser des librairies externes de l'écosystème PHP.

// public/index.php

// 1. Intégration de l'autoloader Composer (Optionnel)
if (file_exists(dirname(__DIR__) . '/vendor/autoload.php')) {
    require_once dirname(__DIR__) . '/vendor/autoload.php';
}

// 2. Chargement de l'autoloader natif de CoreEngine
require_once dirname(__DIR__) . '/vendor/coreengine-autoload.php';
                

Chaque interaction avec CoreEngine suit un flux linéaire et sécurisé, transformant une Request en Response à travers une pile de composants intelligents.

public function store(Request $request) {
    $email = $request->input('email');
    $data  = $request->only(['name', 'role']);
    $id    = $request->param('id'); // Param de route
}
                        

Response::json(['status' => 'success'], 201);
Response::redirect('/dashboard');
Response::notFound("Article introuvable");
                        

Le routeur de CoreEngine est un moteur de résolution dynamique. Il gère l'extraction de paramètres via Regex, l'injection automatique de dépendances et une pile de middlewares bidirectionnelle.

// Closure simple
Route::get('/api/status', fn() => ["status" => "ok"]);

// Rendu direct (resources/Views/welcome.php)
Route::view('/', 'welcome');
                            

Route::controller(UserController::class, function($router) {
    $router->get('/profile', 'show');
    $router->post('/profile', 'update');
});
                            

public function __construct(Database $db, Mailer $mail) {
    $this->db = $db;
}
                            

Route::get('/admin', [AdminController::class, 'index'], [
    AuthMiddleware::class,
    AdminMiddleware::class
]);
                        

Les middlewares agissent comme des gardiens. Ils interceptent la Request avant qu'elle n'atteigne le contrôleur, permettant de filtrer, valider ou rediriger le flux selon des règles métier précises.

namespace App\Middlewares;

use Config\Facades\Http\Request;
use Config\Facades\Http\Response;

class AuthMiddleware {
    public function handle(Request $request, callable $next) {
        if (!isset($_SESSION['user'])) {
            return Response::redirect('/login');
        }

        return $next($request);
    }
}
                        

Route::get('/admin/dashboard', [AdminController::class, 'index'], [
    \App\Middlewares\AuthMiddleware::class,
    \App\Middlewares\RoleAdminMiddleware::class
]);
                    

La connexion n'est pas simplement globale : elle est injectée via le Container. Le DatabaseServiceProvider centralise la configuration, rendant la base de données disponible partout de manière découplée et hautement performante.

$container->set(PDO::class, function () {
    // Charge l'instance PDO depuis la config centrale
    return require 'config/database.php';
});

// Initialise la Facade DB avec l'instance résolue
DB::boot($container->get(PDO::class));
                        

Avant l'ORM, il y a le Query Builder. C'est une interface fluide et sécurisée pour construire des requêtes SQL complexes via la façade DB. Il est idéal pour les requêtes qui ne nécessitent pas d'hydratation en Modèles.

// Sélectionner des utilisateurs actifs
$users = DB::table('users')
            ->select('id', 'email')
            ->where('status', '=', 'active')
            ->orderBy('created_at', 'DESC')
            ->get(); // Retourne une Collection de tableaux associatifs

// Compter les articles
$count = DB::table('articles')->count();

// Insertion
$id = DB::table('logs')->insert([
    'level' => 'info',
    'message' => 'User logged in'
]);
            

L'interface en ligne de commande de CoreEngine automatise la création de fichiers et la gestion de la base de données. Elle intègre une détection intelligente de l'environnement pour faciliter le passage entre Docker et votre système hôte.

Les contrôleurs étendent la classe Config\Facades\Controllers\Controllers. Ils bénéficient de l'injection automatique de PDO et de méthodes utilitaires pour le rendu, les API et la gestion de fichiers.

namespace App\Controllers;
use Config\Facades\Controllers\Controllers;
use Config\Facades\Http\Request;

class UserController extends Controllers {
    public function index(Request $request) {
        return $this->render('users/profile', [
            'user' => 'Jalal'
        ]);
    }
}
                    

// Réponse JSON structurée
return $this->response("1", true, $data, "Succès", 200);

// Téléchargement sécurisé
return $this->makeDownload('facture.pdf');
                    

L'ORM de CoreEngine repose sur un QueryBuilder fluide et un système de Single Source of Truth. Le schéma de votre base de données est défini directement dans vos modèles, permettant l'auto-migration et une protection stricte des données.

class UserModel extends Models {
    protected static string $tableName = 'users';

    // Définition SQL + Protection de masse
    protected static array $schemaColumns = [
        "id"        => "INT AUTO_INCREMENT PRIMARY KEY",
        "email"     => "VARCHAR(255) NOT NULL UNIQUE",
        "firstName" => "VARCHAR(100)",
        "password"  => "VARCHAR(255) NOT NULL",
        "role_id"   => "INT DEFAULT 1"
    ];
}
                    

// Récupère une Collection d'objets UserModel
$users = UserModel::where('role_id', '=', 2)
                ->orderBy('firstName', 'DESC')
                ->limit(10)
                ->get();

// Hydratation automatique depuis un ID
$user = UserModel::find(1);
                    

$user = new UserModel();
$user->firstName = "Jalal"; // Vérifie si 'firstName' existe dans $schemaColumns
$user->save();              // INSERT - ID généré automatiquement

$user->email = "jalal@coreengine.dev";
$user->save();              // UPDATE - L'ID est présent, le moteur cible l'enregistrement
                

Les Collections sont des enveloppes puissantes pour les tableaux de données. Elles sont retournées automatiquement par le QueryBuilder et offrent des méthodes de manipulation chaînables.

$users = UserModel::all();

// Extraire uniquement les emails
$emails = $users->pluck('email');

// Filtrer les admins et trier par nom
$admins = $users->filter(function($user) {
    return $user->role === 'admin';
})->sortBy('firstName', 'asc');
                        

// Calculer le total des factures
$total = $invoices->sum('amount');

// Grouper les utilisateurs par ville
$cities = $users->groupBy('city');

// Vérification rapide
if ($users->isEmpty()) {
    // ...
}
                        

La sécurité des données est intégrée nativement. Le Validator permet de vérifier l'intégrité des entrées utilisateur avant tout traitement, tandis que les Modèles protègent la base de données via un filtrage par colonnes.

class User extends Models {
    protected static array $rules = [
        'email'    => 'required|email',
        'password' => 'required|min:8',
        'age'      => 'number',
        'status'   => 'boolean'
    ];
}
                        

public function store(Request $request) {
    $validation = User::validate($request->all());

    if (!$validation['success']) {
        return view('register', [
            'errors' => $validation['errors']
        ]);
    }

    // Données filtrées et validées
    $user = (new User())->fill($validation['data']);
    $user->save();
}
                        

CoreEngine intègre un système d'authentification complet via la façade Auth et une gestion des permissions via la façade Role.

// Vérifier si l'utilisateur est connecté
if (Auth::check()) { ... }

// Récupérer l'ID de l'utilisateur connecté
$userId = Auth::id();

// Récupérer le modèle User complet
$user = Auth::user();

// Connecter un utilisateur (après vérification du mot de passe)
Auth::login($userModelInstance);

// Déconnecter l'utilisateur
Auth::logout();
                    

// Vérifier si l'utilisateur a un rôle spécifique
if (Role::is('ADMIN')) {
    // Logique réservée aux administrateurs
}

// Vérifier si l'utilisateur a l'un des rôles
if (Role::isOneOf(['ADMIN', 'MODERATOR'])) {
    // ...
}

// Middleware de rôle
class RoleAdminMiddleware {
    public function handle(Request $request, callable $next) {
        if (!Role::is('ADMIN')) {
            return Response::redirect('/unauthorized');
        }
        return $next($request);
    }
}
                    

CoreEngine utilise un système de rendu basé sur PHP pur pour une performance maximale. Les vues sont isolées, ce qui signifie qu'elles n'ont accès qu'aux variables que vous leur passez explicitement.

// Dans le Router
Route::view('/', 'home');

// Dans un Contrôleur
return $this->render('user/profile', [
    'name' => 'Jalal',
    'role' => 'Admin'
]);
                        

CoreEngine fournit une interface unifiée pour l'envoi d'e-mails et la journalisation. Basé sur le Design Pattern Factory, le module Mail vous permet de basculer instantanément entre différents fournisseurs.

use Config\Facades\Mail\Mail;

// Configuration via .env (MAIL_DRIVER=sendgrid|resend|smtp)
Mail::to('client@exemple.com')
    ->cc('admin@exemple.com')
    ->subject('Votre Commande')
    ->html('<h1>Merci !</h1>')
    ->send();
                        

use Config\Facades\Log;

Log::info("Nouvel utilisateur inscrit");
Log::warning("Tentative de connexion échouée");
Log::exception("Erreur inattendue détectée");
                        

Apprenez à combiner Modèle, ORM, Validation et Contrôleur pour construire un système complet de gestion de tâches (Create, Read, Update, Delete).

// app/Models/Task.php
class Task extends Models {
    protected static string $tableName = 'tasks';
    
    protected static array $schemaColumns = [
        "id"          => "INT AUTO_INCREMENT PRIMARY KEY",
        'title'       => 'VARCHAR(255) NOT NULL',
        'user_id'     => 'INT NOT NULL',
        'is_done'     => 'BOOLEAN DEFAULT FALSE'
    ];
    
    protected static array $rules = [
        'title' => 'required|min:3|max:50',
    ];
}
                    

// app/Controllers/TaskController.php
class TaskController extends Controllers {
    // Affiche la liste des tâches et le formulaire
    public function index() {
        $tasks = Task::where('user_id', Auth::id())->get();
        return $this->render('tasks/index', ['tasks' => $tasks]);
    }

    // Enregistre une nouvelle tâche
    public function store(Request $request) {
        $validation = Task::validate($request->all());
        if (!$validation['success']) {
            // Gérer les erreurs...
            return Response::redirect('/tasks');
        }

        $task = new Task();
        $task->fill($validation['data']);
        $task->user_id = Auth::id();
        $task->save();

        return Response::redirect('/tasks');
    }

    // Met à jour le statut d'une tâche
    public function update(Request $request) {
        $task = Task::find($request->param('id'));
        // Vérifier que la tâche appartient à l'utilisateur connecté
        if ($task && $task->user_id == Auth::id()) {
            $task->is_done = !$task->is_done;
            $task->save();
        }
        return Response::redirect('/tasks');
    }

    // Supprime une tâche
    public function destroy(Request $request) {
        $task = Task::find($request->param('id'));
        if ($task && $task->user_id == Auth::id()) {
            $task->delete();
        }
        return Response::redirect('/tasks');
    }
}
                    

// routes/web.php
Route::middlewares([AuthMiddleware::class], function() {
    Route::get('/tasks', [TaskController::class, 'index']);
    Route::post('/tasks', [TaskController::class, 'store']);
    Route::post('/tasks/{id}/update', [TaskController::class, 'update']);
    Route::post('/tasks/{id}/delete', [TaskController::class, 'destroy']);
});
                    

Apprenez à protéger des sections de votre site avec les Middlewares et à afficher des données spécifiques à l'utilisateur connecté.

// app/Middlewares/AuthMiddleware.php
class AuthMiddleware implements Middleware {
    public function handle(Request $request, callable $next) {
        if (!Auth::check()) {
            return Response::redirect('/signin');
        }
        return $next($request);
    }
}
                    

// routes/web.php
Route::middlewares([AuthMiddleware::class], function() {
    Route::get('/dashboard', [DashboardController::class, 'index']);
    Route::get('/profile', [ProfileController::class, 'show']);
    // ... toutes vos autres routes membres
});
                    

// app/Controllers/DashboardController.php
class DashboardController extends Controllers {
    public function index() {
        $user = Auth::user(); // Récupère l'objet UserModel complet
        $tasks = Task::where('user_id', $user->id)->get();
        $taskCount = $tasks->count();

        return $this->render('dashboard', [
            'user' => $user,
            'tasks' => $tasks,
            'taskCount' => $taskCount
        ]);
    }
}
                    

<h1>Bienvenue, <?= $user->firstName ?> !</h1>
<p>Vous avez <?= $taskCount ?> tâches en cours.</p>

<ul>
<?php foreach($tasks as $task): ?>
    <li><?= $task->title ?></li>
<?php endforeach; ?>
</ul>
                    

Créez une API stateless et sécurisée pour gérer vos tâches. Idéal pour une application front-end (React, Vue.js) ou une app mobile.

// app/Middlewares/ApiAuthMiddleware.php
class ApiAuthMiddleware implements Middleware { // Note: `Middleware` interface should be imported
    public function handle(Request $request, callable $next) {
        $authHeader = $request->header('Authorization');
        $token = null;

        if ($authHeader && str_starts_with($authHeader, 'Bearer ')) {
            $token = substr($authHeader, 7);
        }

        if (!$token) {
            return Response::json(['message' => 'Unauthorized'], 401);
        }

        // Cherche l'utilisateur par son token
        $user = UserModel::where('api_token', '=', $token)->first();

        if (empty($user)) {
            return Response::json(['message' => 'Invalid token'], 401);
        }

        // Authentifie l'utilisateur pour cette requête
        Auth::login($user);

        return $next($request);
    }
}
                    

// app/Controllers/Api/TaskController.php
class TaskController extends Controllers {
    public function index() {
        $tasks = Task::where('user_id', Auth::id())->get();
        return $this->response("1", true, $tasks, "Tasks retrieved");
    }

    public function store(Request $request) {
        // ... validation ...
        $task = new Task();
        $task->fill($request->only(['title']));
        $task->user_id = Auth::id();
        $task->save();
        return $this->response("1", true, $task, "Task created", 201);
    }
    // ... méthodes show, update, destroy ...
}
                    

// routes/web.php
Route::prefix('api', function() {
    Route::middlewares([ApiAuthMiddleware::class], function() {
        Route::get('/tasks', [Api\TaskController::class, 'index']);
        Route::post('/tasks', [Api\TaskController::class, 'store']);
        Route::get('/tasks/{id}', [Api\TaskController::class, 'show']);
        Route::put('/tasks/{id}', [Api\TaskController::class, 'update']);
        Route::delete('/tasks/{id}', [Api\TaskController::class, 'destroy']);
    });
});
                    

# Récupérer les tâches
curl -X GET http://localhost:8081/api/tasks \
-H "Authorization: Bearer VOTRE_API_TOKEN"

# Créer une tâche
curl -X POST http://localhost:8081/api/tasks \
-H "Authorization: Bearer VOTRE_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{"title": "Apprendre CoreEngine"}'
                    

Mettez en pratique la validation et le module d'envoi d'e-mails en créant un formulaire de contact fonctionnel.

// app/Controllers/ContactController.php
use Config\Facades\Validation\Validator;
use Config\Facades\Mail\Mail;

class ContactController extends Controllers {
    public function index() {
        return $this->render('contact/form');
    }

    public function send(Request $request) {
        $validator = new Validator();
        $rules = [
            'name' => 'required|text',
            'email' => 'required|email',
            'message' => 'required|min:10'
        ];

        if (!$validator->validate($request->all(), $rules)) {
            // Rediriger avec les erreurs et les anciennes données
            return $this->render('contact/form', [
                'errors' => $validator->errors(),
                'old' => $request->all()
            ]);
        }

        // Envoi de l'email à l'administrateur
        Mail::to(env('ADMIN_EMAIL', 'admin@test.com'))
            ->replyTo($request->input('email'))
            ->subject('Nouveau message de ' . $request->input('name'))
            ->text($request->input('message'))
            ->send();

        // Rediriger avec un message de succès
        return $this->render('contact/form', ['success' => true]);
    }
}
                    

// routes/web.php
Route::get('/contact', [ContactController::class, 'index']);
Route::post('/contact', [ContactController::class, 'send']);
                    

<?php if(isset($success)): ?> <div class="alert-success">Message envoyé !</div> <?php else: ?> <?php if(isset($errors)): ?> <ul class="alert-danger"> <?php foreach($errors as $field => $error): ?> <li><?= htmlspecialchars($error[0]) ?></li> <?php endforeach; ?> </ul> <?php endif; ?> <form action="/contact" method="POST"> <?= csrf_field() ?> <input type="text" name="name" value="<?= htmlspecialchars($old['name'] ?? '') ?>"> <input type="email" name="email" value="<?= htmlspecialchars($old['email'] ?? '') ?>"> <textarea name="message"><?= htmlspecialchars($old['message'] ?? '') ?></textarea> <button type="submit">Envoyer</button> </form> <?php endif; ?>