@akuma225/request-context

Service de gestion du contexte de requête pour NestJS. Permet d'accéder facilement aux données de la requête HTTP depuis n'importe où dans votre application.

Installation

npm install @akuma225/request-context

Configuration

Importez le module dans votre AppModule :

import { Module } from '@nestjs/common';
import { RequestContextModule } from '@akuma225/request-context';

@Module({
  imports: [RequestContextModule],
})
export class AppModule {}

Le module est automatiquement configuré comme global, donc vous n'avez pas besoin de l'importer dans d'autres modules.

Utilisation

Dans un service

import { Injectable } from '@nestjs/common';
import { RequestContextService } from '@akuma225/request-context';

@Injectable()
export class UserService {
  constructor(private readonly requestContext: RequestContextService) {}

  async getCurrentUser() {
    // Récupérer l'utilisateur de la requête
    const user = this.requestContext.getUser();
    return user;
  }

  async someMethod() {
    // Récupérer toute la requête
    const request = this.requestContext.get();

    // Récupérer une valeur spécifique
    const specificValue = this.requestContext.get('someKey');

    // Récupérer le corps de la requête
    const body = this.requestContext.getBody();

    // Récupérer les paramètres de route
    const params = this.requestContext.getParams();

    // Récupérer les paramètres de requête
    const query = this.requestContext.getQuery();

    // Récupérer les en-têtes
    const headers = this.requestContext.getHeaders();
  }
}

Dans un contrôleur

import { Controller, Get } from '@nestjs/common';
import { RequestContextService } from '@akuma225/request-context';

@Controller('users')
export class UserController {
  constructor(private readonly requestContext: RequestContextService) {}

  @Get('me')
  async getMe() {
    const user = this.requestContext.getUser();
    return user;
  }
}

Dans un guard

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { RequestContextService } from '@akuma225/request-context';

@Injectable()
export class AuthGuard implements CanActivate {
  constructor(private readonly requestContext: RequestContextService) {}

  canActivate() {
    const headers = this.requestContext.getHeaders();
    const token = headers.authorization;
    // Votre logique d'authentification...
    return true;
  }
}

Dans un intercepteur

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { RequestContextService } from '@akuma225/request-context';

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  constructor(private readonly requestContext: RequestContextService) {}

  intercept(context: ExecutionContext, next: CallHandler) {
    const request = this.requestContext.get();
    console.log(`Request URL: ${request.url}`);
    return next.handle();
  }
}

Méthodes disponibles

| Méthode | Description | |---------|-------------| | get<T>() | Récupère toute la requête | | get<T>(key: string) | Récupère une valeur spécifique de la requête | | find<T>(path: string) | Recherche une valeur imbriquée en utilisant une notation par points (e.g., 'metadata.id') | | getParams<T>() | Récupère les paramètres de route | | getBody<T>() | Récupère le corps de la requête | | getQuery<T>() | Récupère les paramètres de requête | | getHeaders<T>() | Récupère les en-têtes de la requête | | getUser<T>() | Récupère l'utilisateur de la requête |

Exemple d'utilisation de find()

@Injectable()
export class MyService {
  constructor(private readonly requestContext: RequestContextService) {}

  someMethod() {
    // Récupérer une valeur imbriquée
    const metadataId = this.requestContext.find<string>('metadata.id');
    const userRole = this.requestContext.find<string>('user.profile.role');
    const deepValue = this.requestContext.find('very.deep.nested.value');

    // Avec typage TypeScript
    interface Metadata {
      id: string;
      timestamp: Date;
    }
    const metadata = this.requestContext.find<Metadata>('metadata');
  }
}

## Bonnes pratiques

1. **Injection de dépendances**
   - Injectez le service uniquement là où vous en avez besoin
   - Utilisez le typage générique pour une meilleure sécurité de type

2. **Performance**
   - Le service utilise le scope REQUEST, donc une nouvelle instance est créée pour chaque requête
   - Les données sont stockées en mémoire uniquement pendant la durée de la requête

3. **Sécurité**
   - Ne stockez pas de données sensibles dans le contexte
   - Validez toujours les données récupérées du contexte

## Contribution

Les contributions sont les bienvenues ! N'hésitez pas à ouvrir une issue ou à soumettre une pull request.

## Licence

MIT