Cache em TypeScript: Redis e outras soluções

Cache em TypeScript: Redis, Memcached e soluções in-memory

Cache é um dos mecanismos-chave para otimizar o desempenho de aplicações web. No ecossistema TypeScript e Node.js, existem várias abordagens comprovadas para organizar o cache: desde soluções simples in-memory até sistemas distribuídos baseados em Redis e Memcached. Neste artigo, vamos detalhar as bibliotecas populares, sua instalação, configuração e exemplos de uso.

Por que usar cache?

O cache permite reduzir o tempo de resposta do servidor, diminuir a carga em bancos de dados e APIs externas, além de melhorar a experiência do usuário. Os principais cenários de uso incluem:

Armazenar resultados de cálculos custosos
Armazenar respostas de APIs externas
Armazenar sessões de usuários
Armazenar fragmentos de páginas HTML

1. ioredis — cliente avançado para Redis

ioredis é a biblioteca mais popular para trabalhar com Redis em Node.js e TypeScript. Ela suporta clusterização, Pub/Sub, transações e reconexão automática.

Instalação:

npm install ioredisnpm install @types/ioredis --save-dev

Uso básico com TypeScript:

import Redis from 'ioredis';

// Conexão com Redis localconst redis = new Redis({    host: 'localhost',    port: 6379,    retryStrategy: (times) => Math.min(times * 50, 2000)});

// Função para armazenar dados em cacheasync function getCachedData(key: string): Promise<string | null> {    const cached = await redis.get(key);    if (cached) {        console.log('Dados do cache');        return cached;    }    // Simulação de obtenção de dados do banco    const data = `Data for ${key} at ${new Date().toISOString()}`;    await redis.setex(key, 3600, data); // TTL 1 hora    return data;}

// Exemplo de uso(async () => {    const result = await getCachedData('user:123');    console.log(result);})();

Cache de objetos:

interface User {    id: number;    name: string;    email: string;}

async function cacheUser(user: User): Promise<void> {    await redis.setex(`user:${user.id}`, 3600, JSON.stringify(user));}

async function getUserFromCache(id: number): Promise<User | null> {    const cached = await redis.get(`user:${id}`);    return cached ? JSON.parse(cached) : null;}

2. node-cache — cache in-memory simples

node-cache é uma biblioteca leve para armazenar dados na memória RAM do processo Node.js. Ideal para projetos pequenos ou protótipos onde não é necessário cache distribuído.

Instalação:

npm install node-cachenpm install @types/node-cache --save-dev

Exemplo de uso:

import NodeCache from 'node-cache';

const myCache = new NodeCache({    stdTTL: 600, // tempo de vida padrão (segundos)    checkperiod: 120 // período de verificação de chaves expiradas});

// Salvar e obter dadosmyCache.set('key1', { value: 42 });const value = myCache.get('key1');console.log(value); // { value: 42 }

// Verificar existência da chaveif (myCache.has('key1')) {    console.log('Chave existe');}

// Remover por chavemyCache.del('key1');

// Obter estatísticasconst stats = myCache.getStats();console.log(`Chaves no cache: ${stats.keys}`);

3. lru-cache — cache com política LRU

lru-cache é uma implementação de cache com algoritmo de despejo Least Recently Used. Limita o número de entradas armazenadas, removendo automaticamente as mais antigas. Excelente para cache com tamanho fixo.

Instalação: