@akuma225/request-executor

Une bibliothèque NestJS moderne et complète pour l'exécution simplifiée de requêtes HTTP externes avec gestion d'erreurs avancée, logging automatique et configuration flexible.

🚀 Fonctionnalités

• Exécution de requêtes HTTP : Support complet des méthodes GET, POST, PUT, DELETE, PATCH
• Gestion d'erreurs avancée : Gestion automatique des erreurs avec options de personnalisation
• Logging automatique : Logs configurables pour les requêtes et les erreurs
• Intégration NestJS native : Module avec injection de dépendances
• TypeScript complet : Types stricts et interfaces détaillées
• Configuration flexible : Options personnalisables pour chaque requête
• Gestion des réponses : Extraction automatique des données de réponse
• Support Axios : Basé sur Axios pour une compatibilité maximale

📦 Installation

npm install @akuma225/request-executor

ou

yarn add @akuma225/request-executor

🔧 Configuration

Import du module

import { Module } from '@nestjs/common';
import { AkumaRequestExecutorModule } from '@akuma225/request-executor';

@Module({
  imports: [AkumaRequestExecutorModule],
  // ...
})
export class AppModule {}

🔧 Utilisation

Injection du service

import { Injectable } from '@nestjs/common';
import { AkumaExternalRequestExecutorService } from '@akuma225/request-executor';

@Injectable()
export class UserService {
  constructor(
    private readonly requestExecutor: AkumaExternalRequestExecutorService
  ) {}

  async fetchUsers() {
    return this.requestExecutor.executeRequest({
      method: 'GET',
      url: 'https://api.example.com/users',
      logMessage: 'Récupération des utilisateurs',
      errorMessage: 'Erreur lors de la récupération des utilisateurs'
    });
  }
}

Requête POST avec données

async createUser(userData: any) {
  return this.requestExecutor.executeRequest({
    method: 'POST',
    url: 'https://api.example.com/users',
    body: userData,
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    logMessage: 'Création d\'un nouvel utilisateur',
    logData: { userData },
    errorMessage: 'Erreur lors de la création de l\'utilisateur'
  });
}

Gestion d'erreurs personnalisée

async updateUser(id: string, userData: any) {
  return this.requestExecutor.executeRequest({
    method: 'PUT',
    url: `https://api.example.com/users/${id}`,
    body: userData,
    throwError: false, // Ne pas lancer d'exception
    overrideErrorMessageByResponseData: true, // Utiliser le message d'erreur de l'API
    logMessage: 'Mise à jour de l\'utilisateur',
    errorMessage: 'Erreur lors de la mise à jour de l\'utilisateur'
  });
}

Requête avec paramètres

async searchUsers(query: string) {
  return this.requestExecutor.executeRequest({
    method: 'GET',
    url: 'https://api.example.com/users/search',
    params: {
      q: query,
      limit: 10,
      offset: 0
    },
    logMessage: 'Recherche d\'utilisateurs',
    logData: { query }
  });
}

📋 Interface RequestOptions

interface RequestOptions {
  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
  url: string;
  body?: any;                                    // Corps de la requête
  headers?: Record<string, any>;                 // En-têtes HTTP
  params?: Record<string, any>;                  // Paramètres de requête
  logMessage?: string;                           // Message de log
  logData?: any;                                 // Données supplémentaires pour le log
  errorMessage?: string;                         // Message d'erreur personnalisé
  overrideErrorMessageByResponseData?: boolean;  // Utiliser le message d'erreur de l'API
  throwError?: boolean;                          // Lancer une exception en cas d'erreur
}

📋 Classe ExternalServiceError

class ExternalServiceError {
  error_message: string;  // Message d'erreur
  error_code: number;     // Code d'erreur HTTP
  error_data: any;        // Données d'erreur supplémentaires
}

🔍 Exemples d'utilisation avancée

Service complet avec gestion d'erreurs

import { Injectable } from '@nestjs/common';
import { AkumaExternalRequestExecutorService, ExternalServiceError } from '@akuma225/request-executor';

@Injectable()
export class ExternalApiService {
  constructor(
    private readonly requestExecutor: AkumaExternalRequestExecutorService
  ) {}

  async callExternalApi() {
    const result = await this.requestExecutor.executeRequest({
      method: 'POST',
      url: 'https://external-api.com/data',
      body: { key: 'value' },
      headers: {
        'Authorization': 'Bearer token',
        'Content-Type': 'application/json'
      },
      logMessage: 'Appel API externe',
      throwError: false
    });

    // Vérifier si c'est une erreur
    if (result instanceof ExternalServiceError) {
      console.error('Erreur API:', result.error_message);
      return null;
    }

    return result;
  }
}

Gestion des timeouts et retry

async fetchWithRetry(url: string, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      return await this.requestExecutor.executeRequest({
        method: 'GET',
        url,
        logMessage: `Tentative ${i + 1}/${retries}`,
        errorMessage: `Échec de la tentative ${i + 1}/${retries}`
      });
    } catch (error) {
      if (i === retries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
    }
  }
}

🧪 Tests

# Exécuter les tests
npm test

# Tests en mode watch
npm run test:watch

# Tests avec couverture
npm run test:coverage

🔧 Scripts disponibles

• npm run build - Compiler la bibliothèque
• npm run dev - Compiler en mode watch
• npm run clean - Nettoyer le dossier dist
• npm run lint - Vérifier le code avec ESLint
• npm run lint:fix - Corriger automatiquement les erreurs ESLint

📄 Licence

MIT

🤝 Contribution

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

📞 Support

Pour toute question ou problème, veuillez ouvrir une issue sur GitHub.