O cache é uma técnica fundamental para melhorar o desempenho e a escalabilidade de suas aplicações. No Nest.js, o cache pode ser perfeitamente integrado usando o gerenciador de cache integrado. Neste artigo, exploraremos como criar um decorador @Cacheable personalizado para simplificar o armazenamento em cache em seus serviços ou controladores Nest.js.

? Por que usar um decorador @Cacheable personalizado?

Embora o Nest.js forneça mecanismos de cache poderosos prontos para uso, aplicar a lógica de cache diretamente em seus métodos pode sobrecarregar seu código. Um decorador personalizado abstrai essa lógica, tornando seu código mais limpo e mais fácil de manter.

? Criando o decorador @Cacheable

Vamos começar criando o decorador @Cacheable que usaremos para armazenar em cache os resultados de nossos 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;
  };
}

? Explicação

• Cache Retrieval: Antes de executar o método original, o decorador verifica se o resultado já está armazenado em cache.
• Cache Miss Handling: Se o resultado não estiver no cache, ele executa o método original e então armazena o resultado em cache.
• Tratamento de erros: captura e registra quaisquer erros durante a recuperação ou configuração do cache, garantindo que seu aplicativo não trave devido a problemas de cache.

? Usando o decorador @Cacheable

Veja como você pode aplicar o decorador @Cacheable a um método em seu serviço:

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

? Explicação

• Aplicativo Decorador: O decorador @Cacheable é aplicado ao método getSettings() com uma chave de cache específica.
• Injeção de Dependência: O gerenciador de cache é injetado no serviço para ser usado pelo decorador.

? Integrando o Gerenciador de Cache no Nest.js

Para usar o gerenciador de cache em sua aplicação, você precisa registrá-lo em seu 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 {}

? Explicação

• Global Cache: A configuração isGlobal: true disponibiliza o gerenciador de cache em todo o seu aplicativo.
• TTL e máximo de itens: Configure o tempo de vida (ttl) e o número máximo de itens (max) no cache.

? Injetando o Gerenciador de Cache

Certifique-se de injetar o gerenciador de cache em qualquer serviço ou controlador que use o decorador @Cacheable:

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

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

  // ... your methods
}

? Conclusão

Ao criar um decorador @Cacheable personalizado, você pode manter seus métodos limpos e focar na lógica central, deixando as preocupações de cache para o decorador. Essa abordagem melhora a legibilidade e a manutenção do código, tornando seu aplicativo Nest.js mais eficiente e escalonável.

Sinta-se à vontade para deixar comentários ou perguntas abaixo. Boa codificação! ?