La mise en cache est une technique fondamentale pour améliorer les performances et l'évolutivité de vos applications. Dans Nest.js, la mise en cache peut être intégrée de manière transparente à l'aide du gestionnaire de cache intégré. Dans cet article, nous découvrirons comment créer un décorateur @Cacheable personnalisé pour simplifier la mise en cache dans vos services ou contrôleurs Nest.js.

? Pourquoi utiliser un décorateur @Cacheable personnalisé ?

Bien que Nest.js fournisse de puissants mécanismes de mise en cache prêts à l'emploi, l'application d'une logique de mise en cache directement dans vos méthodes peut encombrer votre code. Un décorateur personnalisé fait abstraction de cette logique, rendant votre code plus propre et plus maintenable.

? Création du décorateur @Cacheable

Commençons par créer le décorateur @Cacheable que nous utiliserons pour mettre en cache les résultats de nos méthodes.

import { Cache } from 'cache-manager';

export function Cacheable(cacheKey: string) {
  return function (
    target: any,
    propertyName: string,
    descriptor: PropertyDescriptor,
  ) {
    const originalMethod = descriptor.value;

    descriptor.value = async function (...args: any[]) {
      const cache: Cache = this.cacheManager;

      if (!cache) {
        throw new Error(
          'Cannot use Cacheable() decorator without injecting the cache manager.',
        );
      }

      // Try to get cached data
      try {
        const cachedResult = await cache.get(cacheKey);
        if (cachedResult) {
          return cachedResult;
        }
      } catch (error) {
        console.error(`Cache get error for key: ${cacheKey}:`, error);
      }

      // Call the original method if cache miss
      const result = await originalMethod.apply(this, args);

      // Set the new result in cache
      try {
        await cache.set(cacheKey, result);
      } catch (error) {
        console.error(`Cache set error for key: ${cacheKey}:`, error);
      }

      return result;
    };

    return descriptor;
  };
}

? Explication

• Récupération du cache : Avant d'exécuter la méthode d'origine, le décorateur vérifie si le résultat est déjà mis en cache.
• Cache Miss Handling : si le résultat n'est pas dans le cache, il exécute la méthode d'origine puis met le résultat en cache.
• Gestion des erreurs : détecte et enregistre toutes les erreurs lors de la récupération ou de la configuration du cache, garantissant ainsi que votre application ne plante pas en raison de problèmes de mise en cache.

? Utilisation du décorateur @Cacheable

Voici comment appliquer le décorateur @Cacheable à une méthode de votre service :

import { Injectable } from '@nestjs/common';
import { Cacheable } from './cacheable.decorator';

const SETTING_CACHE_KEY = 'settings';

@Injectable()
export class SettingsService {
  // Inject the cache manager
  constructor(private readonly cacheManager: Cache) {}

  /**
   * Retrieves settings from the cache if available, or loads them from the
   * repository and caches the result.
   *
   * @returns A promise that resolves to a `Settings` object.
   */
  @Cacheable(SETTING_CACHE_KEY)
  async getSettings(): Promise {
    return await this.findAll();
  }

  // ... other methods like findAll() and buildTree()
}

? Explication

• Application de décorateur : le décorateur @Cacheable est appliqué à la méthode getSettings() avec une clé de cache spécifique.
• Injection de dépendances : Le gestionnaire de cache est injecté dans le service pour être utilisé par le décorateur.

? Intégration du gestionnaire de cache dans Nest.js

Pour utiliser le gestionnaire de cache dans votre application, vous devez l'enregistrer dans votre module :

import { Module } from '@nestjs/common';
import { CacheModule } from '@nestjs/cache-manager';
import { SettingsService } from './settings.service';

@Module({
  imports: [
    CacheModule.register({
      isGlobal: true,
      ttl: 300, // Time to live in seconds
      max: 100, // Maximum number of items in cache
    }),
  ],
  providers: [SettingsService],
})
export class AppModule {}

? Explication

• Global Cache : le paramètre isGlobal : true rend le gestionnaire de cache disponible dans toute votre application.
• TTL et Max Items : configurez la durée de vie (ttl) et le nombre maximum d'éléments (max) dans le cache.

? Injection du gestionnaire de cache

Assurez-vous d'injecter le gestionnaire de cache dans tout service ou contrôleur qui utilise le décorateur @Cacheable :

import { Injectable } from '@nestjs/common';
import { Cache } from 'cache-manager';

@Injectable()
export class SettingsService {
  constructor(private readonly cacheManager: Cache) {}

  // ... your methods
}

? Conclusion

En créant un décorateur @Cacheable personnalisé, vous pouvez garder vos méthodes propres et vous concentrer sur la logique de base, laissant les problèmes de mise en cache au décorateur. Cette approche améliore la lisibilité et la maintenabilité du code, rendant votre application Nest.js plus efficace et évolutive.

N'hésitez pas à laisser des commentaires ou des questions ci-dessous. Bon codage ! ?