Redis Caching in NestJS: I Cut Database Calls by 60% in Production

SELECT
  COUNT(*) FILTER (WHERE status = 'published') as published,
  COUNT(*) FILTER (WHERE status = 'draft') as drafts,
  COUNT(DISTINCT viewer_id) as unique_views
FROM posts
WHERE user_id = $1;

npm install @nestjs/cache-manager cache-manager cache-manager-redis-store redis

// app.module.ts
import { CacheModule } from "@nestjs/cache-manager";
import { redisStore } from "cache-manager-redis-store";

@Module({
  imports: [
    CacheModule.registerAsync({
      isGlobal: true,
      useFactory: async () => ({
        store: await redisStore({
          socket: {
            host: process.env.REDIS_HOST || "localhost",
            port: parseInt(process.env.REDIS_PORT) || 6379,
          },
          ttl: 300, // default 5 minutes
        }),
      }),
    }),
  ],
})
export class AppModule {}

Request comes in
      ↓
Check Redis for cached value
      ↓
Cache HIT?  → return cached data immediately (fast)
Cache MISS? → query database → store in Redis → return data

// src/cache/cache.service.ts
import { Injectable, Inject } from "@nestjs/common";
import { CACHE_MANAGER } from "@nestjs/cache-manager";
import { Cache } from "cache-manager";

@Injectable()
export class CacheService {
  constructor(@Inject(CACHE_MANAGER) private cache: Cache) {}

  async getOrSet<T>(
    key: string,
    fetcher: () => Promise<T>,
    ttl: number = 300,
  ): Promise<T> {
    // Check cache first
    const cached = await this.cache.get<T>(key);
    if (cached) return cached;

    // Cache miss — fetch from source
    const data = await fetcher();

    // Store in cache
    await this.cache.set(key, data, ttl);

    return data;
  }

  async invalidate(key: string): Promise<void> {
    await this.cache.del(key);
  }

  async invalidatePattern(keys: string[]): Promise<void> {
    await Promise.all(keys.map((key) => this.cache.del(key)));
  }
}

// analytics.service.ts
@Injectable()
export class AnalyticsService {
  constructor(
    private prisma: PrismaService,
    private cacheService: CacheService,
  ) {}

  async getUserStats(userId: string) {
    const cacheKey = `analytics:user:${userId}`;

    return this.cacheService.getOrSet(
      cacheKey,
      async () => {
        // This expensive query only runs on cache miss
        const [published, drafts, totalViews] = await Promise.all([
          this.prisma.post.count({
            where: { userId, status: "published" },
          }),
          this.prisma.post.count({
            where: { userId, status: "draft" },
          }),
          this.prisma.postView.count({
            where: { post: { userId } },
          }),
        ]);

        return { published, drafts, totalViews };
      },
      300, // cache for 5 minutes
    );
  }
}

// posts.service.ts
@Injectable()
export class PostsService {
  constructor(
    private prisma: PrismaService,
    private cacheService: CacheService,
  ) {}

  async createPost(userId: string, dto: CreatePostDto) {
    const post = await this.prisma.post.create({
      data: { ...dto, userId },
    });

    // Data changed — invalidate analytics cache
    await this.cacheService.invalidate(`analytics:user:${userId}`);

    return post;
  }

  async updatePost(id: string, userId: string, dto: UpdatePostDto) {
    const post = await this.prisma.post.update({
      where: { id, userId },
      data: dto,
    });

    // Invalidate both the specific post cache and the list cache
    await this.cacheService.invalidatePattern([
      `post:${id}`,
      `posts:user:${userId}`,
      `analytics:user:${userId}`,
    ]);

    return post;
  }

  async deletePost(id: string, userId: string) {
    await this.prisma.post.delete({ where: { id, userId } });

    await this.cacheService.invalidatePattern([
      `post:${id}`,
      `posts:user:${userId}`,
      `analytics:user:${userId}`,
    ]);
  }
}

// Use a centralized key builder
export const CacheKeys = {
  // Single resource
  post: (id: string) => `post:${id}`,
  user: (id: string) => `user:${id}`,

  // Lists
  userPosts: (userId: string, page: number) =>
    `posts:user:${userId}:page:${page}`,

  // Analytics
  userAnalytics: (userId: string) => `analytics:user:${userId}`,

  // Tenant-scoped (for multi-tenant apps)
  tenantProducts: (tenantId: string, page: number) =>
    `products:tenant:${tenantId}:page:${page}`,
};

// Usage
const data = await this.cacheService.getOrSet(
  CacheKeys.userAnalytics(userId),
  () => this.computeAnalytics(userId),
  300,
);

// TTL constants — never hardcode numbers
export const CacheTTL = {
  SHORT: 60, // 1 minute  — frequently changing data
  MEDIUM: 300, // 5 minutes — standard cache
  LONG: 600, // 10 minutes — stable content
  EXTENDED: 3600, // 1 hour    — rarely changes
} as const;

// Usage
await this.cacheService.getOrSet(key, fetcher, CacheTTL.MEDIUM);

// ❌ Wrong — caches all posts, ignores pagination
async getPosts(userId: string, page: number) {
  return this.cacheService.getOrSet(
    `posts:user:${userId}`, // same key for all pages!
    () => this.prisma.post.findMany({ skip: (page-1)*10, take: 10 }),
    300,
  );
}

// ✅ Correct — separate cache per page
async getPosts(userId: string, page: number, limit: number) {
  return this.cacheService.getOrSet(
    `posts:user:${userId}:page:${page}:limit:${limit}`,
    async () => {
      const [posts, total] = await Promise.all([
        this.prisma.post.findMany({
          where: { userId },
          skip: (page - 1) * limit,
          take: limit,
          orderBy: { createdAt: 'desc' },
        }),
        this.prisma.post.count({ where: { userId } }),
      ]);
      return { posts, total, page, limit };
    },
    CacheTTL.SHORT, // shorter TTL for lists — content changes more
  );
}

// ❌ Never cache authentication
async validateToken(token: string) {
  // Always hit the database — stale auth data is a security risk
  return this.prisma.session.findUnique({ where: { token } });
}

// ❌ Never cache user-specific sensitive data with shared keys
// This would leak user A's data to user B if key collision occurs
await this.cache.set('user-data', sensitiveData); // missing userId in key!

// ❌ Never cache write operations
async createOrder(dto: CreateOrderDto) {
  // Always write to DB immediately — never cache writes
  return this.prisma.order.create({ data: dto });
}

// ✅ Cache reads, never writes
// ✅ Always include userId/tenantId in cache keys for user-scoped data
// ✅ Never cache authentication or authorization data

async getOrSet<T>(
  key: string,
  fetcher: () => Promise<T>,
  ttl: number = 300,
): Promise<T> {
  const cached = await this.cache.get<T>(key);

  if (cached) {
    // Log cache hit in production for monitoring
    this.logger.debug(`Cache HIT: ${key}`);
    return cached;
  }

  this.logger.debug(`Cache MISS: ${key}`);

  const start = Date.now();
  const data = await fetcher();
  const duration = Date.now() - start;

  // Log slow DB queries
  if (duration > 500) {
    this.logger.warn(`Slow query cached: ${key} took ${duration}ms`);
  }

  await this.cache.set(key, data, ttl);
  return data;
}

✅ Endpoints called frequently with the same parameters
✅ Expensive aggregation or JOIN queries
✅ Data that doesn't change on every request
✅ Public data (leaderboards, stats, featured content)
✅ Configuration or settings loaded repeatedly

❌ User authentication and sessions
❌ Real-time data (prices, live scores)
❌ Write operations
❌ Highly personalized data with complex cache keys