Les middlewares sont des fonctions appelées avant le gestionnaire de route. Les fonctions middleware ont accès à l'objet de contexte d'hono.

Les fonctions middleware peuvent effectuer les tâches suivantes :

• exécuter n'importe quel code.
• apporter des modifications à l'objet de contexte.

Tu peux implémenter un middleware personnalisé de Danet dans une fonction ou dans une classe avec un décorateur @Injectable(). La classe doit implémenter l'interface DanetMiddleware, néanmoins la fonction n'a pas d'exigences particulières. Commençons par implémenter une fonctionnalité simple en utilisant une classe.

import { Injectable, DanetMiddle, HttpContext, NextFunction } from 'jsr:@danet/core';

@Injectable()
export class LoggerMiddleware implements DanetMiddleware {
  async action(ctx: HttpContext, next: NextFunction) {
    console.log('Request...');
    await next();
  }
}

Injection de dépendances ​

Les middlewares de Danet prennent en charge pleinement l'injection de dépendances. Tout comme avec les injectables et les controllers, ils sont capables d'injecter des dépendances qui sont disponibles dans le même module. Comme d'habitude, cela se fait via le constructor.

Application de middleware ​

Tu peux appliquer des middlewares globalement, à des controllers et à des méthodes.

Pour les middlewares globaux, utilise simplement la méthode addGlobalMiddlewares de l'application Danet comme suit :

...
  const application = new DanetApplication();
  await application.init(AppModule);
  application.addGlobalMiddlewares(LoggerMiddleware); // autant de middlewares que vous voulez ;
...

Pour les controllers et les méthodes, utilisez simplement le décorateur @Middleware ! Comme addGlobalMiddlewares, il peut prendre autant de middlewares que nécessaire en tant qu'arguments.

@Middleware(LoggerMiddleware)
@Controller('todo')
class TodoController {
	@Get('/')
	getWithMiddleware() {
    return 'OK'
    }
};

Middleware fonctionnel ​

La classe LoggerMiddleware que nous avons utilisée est assez simple. Elle ne possède aucun membre, aucune méthode supplémentaire et aucune dépendance. Pourquoi ne pouvons-nous pas simplement la définir dans une fonction simple au lieu d'une classe ? En fait, nous le pouvons. Ce type de middleware s'appelle middleware fonctionnel. Transformons le middleware de journalisation d'une classe en middleware fonctionnel pour illustrer la différence :

import { Injectable, DanetMiddle, HttpContext, NextFunction } from 'jsr:@danet/core';

export async function logger(ctx: HttpContext, next: NextFunction) {
  console.log(`Request...`);
  await next();
};

Et l'utiliser dans TodoController :

@Middleware(logger)
@Controller('todo')
class TodoController {
  @Get('/')
  getWithMiddleware() {
    return 'OK'
  }
};

Middleware multiple ​

Comme mentionné ci-dessus, pour lier plusieurs middleware qui sont exécutés séquentiellement, il suffit de les fournir dans l'ordre de gauche à droite à @Middleware ou à addGlobalMiddleware.

Middleware global ​

Si nous voulons lier du middleware à chaque route enregistrée en une seule fois, il suffit d'utiliser la méthode addGlobalMiddlewares de l'application Danet comme suit:

...
  const application = new DanetApplication();
  await application.init(AppModule);
  application.addGlobalMiddlewares(YourFirstMiddleware, SecondMiddleware); //as many middleware as you want;
...