El almacenamiento en caché es una técnica fundamental para mejorar el rendimiento y la escalabilidad de tus aplicaciones. En Nest.js, el almacenamiento en caché se puede integrar perfectamente mediante el administrador de caché integrado. En este artículo, exploraremos cómo crear un decorador @Cacheable personalizado para simplificar el almacenamiento en caché en sus servicios o controladores Nest.js.

? ¿Por qué utilizar un decorador @Cacheable personalizado?

Si bien Nest.js proporciona potentes mecanismos de almacenamiento en caché listos para usar, aplicar la lógica de almacenamiento en caché directamente dentro de sus métodos puede saturar su código. Un decorador personalizado abstrae esta lógica, haciendo que su código sea más limpio y fácil de mantener.

? Creando el decorador @Cacheable

Comencemos creando el decorador @Cacheable que usaremos para almacenar en caché los resultados de nuestros métodos.

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;
  };
}

? Explicación

• Recuperación de caché: antes de ejecutar el método original, el decorador verifica si el resultado ya está almacenado en caché.
• Manejo de errores de caché: si el resultado no está en el caché, ejecuta el método original y luego almacena en caché el resultado.
• Manejo de errores: detecta y registra cualquier error durante la recuperación o configuración de la caché, lo que garantiza que su aplicación no falle debido a problemas de almacenamiento en caché.

? Usando el decorador @Cacheable

Así es como puedes aplicar el decorador @Cacheable a un método en tu servicio:

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()
}

? Explicación

• Aplicación decorativa: El decorador @Cacheable se aplica al método getSettings() con una clave de caché específica.
• Inyección de dependencia: el administrador de caché se inyecta en el servicio que utilizará el decorador.

? Integración del Administrador de caché en Nest.js

Para usar el administrador de caché en tu aplicación, debes registrarlo en tu módulo:

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 {}

? Explicación

• Caché global: la configuración esGlobal: verdadero hace que el administrador de caché esté disponible en toda su aplicación.
• TTL y máximo de elementos: configura el tiempo de vida (ttl) y el número máximo de elementos (max) en la caché.

? Inyectar el administrador de caché

Asegúrese de inyectar el administrador de caché en cualquier servicio o controlador que utilice el decorador @Cacheable:

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

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

  // ... your methods
}

? Conclusión

Al crear un decorador @Cacheable personalizado, puedes mantener tus métodos limpios y concentrarte en la lógica central, dejando las preocupaciones sobre el almacenamiento en caché al decorador. Este enfoque mejora la legibilidad y el mantenimiento del código, lo que hace que su aplicación Nest.js sea más eficiente y escalable.

No dudes en dejar comentarios o preguntas a continuación. ¡Feliz codificación! ?