Le middleware fournit un mécanisme pratique pour inspecter et filtrer les requêtes HTTP entrant dans votre application. Par exemple, Lithe inclut un middleware qui vérifie si l'utilisateur est authentifié. Sinon, le middleware redirigera l'utilisateur vers l'écran de connexion. Si l'utilisateur est authentifié, le middleware autorise la demande à se poursuivre.

Comment fonctionne le middleware dans Lithe

Dans Lithe, les middlewares sont des fonctions ayant accès à l'objet de requête ($req), à l'objet de réponse ($res) et à la fonction $next dans le cycle requête-réponse de l'application. La fonction $next, lorsqu'elle est invoquée, appelle le middleware suivant dans la pile actuelle.

Les fonctions middleware offrent un moyen pratique d'inspecter, de filtrer et de manipuler les requêtes HTTP entrantes vers votre application. Ils peuvent :

• Exécutez n'importe quel code.
• Modifiez les objets de requête et de réponse.
• Terminer le cycle demande-réponse.
• Appelez le middleware suivant dans la pile.

Si le middleware actuel ne termine pas le cycle requête-réponse, il doit appeler $next() pour passer le contrôle au middleware suivant. Dans le cas contraire, la demande restera en attente.

Éléments d'une fonction middleware

Le code suivant illustre les éléments d'une fonction middleware :

$app->use(function ($req, $res, $next) {
    $next();
});

Où:

• $req : argument de requête HTTP, classiquement appelé $req.
• $res : argument de réponse HTTP, classiquement appelé $res.
• $next : argument de rappel, classiquement appelé $next.

Définir le middleware

Voici un exemple simple de middleware appelé myLogger. Ce middleware imprime le message LOGGED à chaque fois qu'une requête le traverse. Il est défini comme une fonction affectée à une variable appelée myLogger :

$myLogger = function ($req, $res, $next) {
  echo 'LOGGED';
  $next();
};

Remarquez l'appel $next() ci-dessus. Cette fonction appelle le prochain middleware de l'application. $next() n'est pas une fonction PHP ou Lithe intégrée mais est le troisième argument transmis à la fonction middleware. Bien que $next() puisse être nommé n'importe quoi, par convention, il est toujours appelé « suivant ». Pour éviter toute confusion, respectez cette convention.

Imaginez le middleware comme une série de « couches » traversées par les requêtes HTTP avant d'atteindre votre application. Chaque couche peut examiner ou rejeter la demande.

Chargement du middleware

Pour charger un middleware, vous appelez la méthode use() de la classe \Lithe\App, en spécifiant la fonction middleware. Par exemple:

$app = new \Lithe\App;

$myLogger = function ($req, $res, $next) {
    echo 'LOGGED';
    $next();
};

$app->use($myLogger);

$app->get('/', function ($req, $res, $next) {
    $res->send('Hello World!');
});

Chaque fois que l'application reçoit une demande, le message « LOGGED » sera imprimé. L'ordre de chargement des middlewares est important : ceux chargés en premier sont exécutés en premier.

Le middleware myLogger imprime simplement un message, puis transmet la requête au middleware suivant à l'aide de $next().

Utiliser un middleware

Une application Lithe peut utiliser les types de middleware suivants :

• Middleware au niveau de l'application
• Middleware au niveau du routeur
• Middleware tiers

Middleware au niveau de l'application

Vous attachez un middleware au niveau de l'application à une instance de l'application à l'aide des méthodes use() ou METHOD(), où METHOD fait référence à la méthode HTTP (par exemple, GET, PUT, POST) en minuscules.

Cet exemple montre un middleware sans chemin. Le middleware s'exécute à chaque fois qu'une requête est reçue :

$app->use(function ($req, $res, $next) {
    echo 'Hello World!';
    $next();
});

Dans l'exemple ci-dessous, le middleware gère une requête GET vers le chemin /user/:id:

$app->get('/user/:id', function ($req, $res, $next) {
    if ($req->param('id') === '0') {
        return $next();
    } 
    $res->send('ID is not 0');
}, function ($req, $res) {
    $res->send('regular');
});

Middleware au niveau du routeur

Le middleware au niveau du routeur fonctionne comme un middleware au niveau de l'application mais est attaché à une instance de \Lithe\Http\Router :

$router = new \Lithe\Http\Router;

Vous chargez un middleware au niveau du routeur à l'aide des fonctions use() et METHOD().

Voici un exemple de middleware au niveau du routeur :

$router = new \Lithe\Http\Router;

$router->use(function ($req, $res, $next) {
    echo 'Time: ', Date('H:i:s'), '
';
    $next();
});

$router->get('/user/:id', function ($req, $res, $next) {
    if ($req->param('id') === '0') {
        $res->redirect('/');
    }
    $next();
}, function ($req, $res) {
    echo $req->param('id');
    $res->render('special');
});

$app->use('/api', $router);

Middleware tiers

Vous pouvez utiliser un middleware tiers pour ajouter des fonctionnalités à vos applications Lithe. Installez le module PHP requis, puis chargez-le au niveau de l'application ou du routeur.

Voici un exemple de chargement d'un middleware de session avec \Lithe\Middleware\Session\session :

use function Lithe\Middleware\Session\session;

$app = new \Lithe\App;

$app->use(session([
    'secure' => true
]));

Pour une liste des middlewares tiers couramment utilisés avec Lithe, consultez la ressource Middleware tiers.

Middleware configurable

Si vous avez besoin que votre middleware soit configurable, vous pouvez créer une fonction qui accepte un tableau d'options ou d'autres paramètres, puis renvoie l'implémentation du middleware en fonction de ces paramètres. Voir l'exemple ci-dessous :

Vous pouvez désormais utiliser le middleware avec des configurations personnalisées :



$app->use(my_middleware(['option1' => '1', 'option2' => '2']));




Pour créer un middleware que d'autres développeurs peuvent installer via Composer, il existe un package appelé lithemod/flow. Il fournit des interfaces et des utilitaires pour gérer les requêtes et les réponses HTTP dans Lithe, ce qui facilite la création de middlewares standardisés et prêts à l'emploi dans diverses applications.

lithemod/flow aide à créer des middlewares robustes en fournissant une interface unifiée pour les requêtes et les réponses, rendant le développement plus efficace et organisé. Cela simplifie l'intégration de votre middleware dans d'autres projets et garantit que le code respecte des normes cohérentes.