Level Up Your NestJS App with RedisX

Straight to the point: you've been using ioredis for your NestJS project. It's fine for a while, but as your app gets beefier, you might notice a few gaps. Enter RedisX. This toolkit is like giving your Redis operations a boost of steroids—modular, organized, and makes your life easier.

Why Ditch ioredis for RedisX?

Manually handling Redis operations with ioredis feels like juggling chainsaws. You're managing connections, figuring out caching, and handling locks all on your own. That's a lot of balls in the air. RedisX steps in to tidy things up. It integrates neatly with NestJS, offering a unified API that keeps your code clean and your sanity intact.

Migration in Four Steps

Step 1: Grab the Packages

First things first, let's get the core and plugins you need. Run this command:

npm install @nestjs-redisx/core @nestjs-redisx/cache @nestjs-redisx/locks

Step 2: Set Up Redis Module

Tear out that old ioredis setup. In your AppModule, configure RedisX:

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { RedisModule } from '@nestjs-redisx/core';
import { CachePlugin } from '@nestjs-redisx/cache';
import { LocksPlugin } from '@nestjs-redisx/locks';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    RedisModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      plugins: [
        CachePlugin.registerAsync({
          inject: [ConfigService],
          useFactory: (config: ConfigService) => ({
            defaultTtl: config.get('CACHE_TTL', 300),
          }),
        }),
        new LocksPlugin({ retryAttempts: 3 }),
      ],
      useFactory: (config: ConfigService) => ({
        clients: {
          type: 'single',
          host: config.get('REDIS_HOST', 'localhost'),
          port: config.get('REDIS_PORT', 6379),
        },
      }),
    }),
  ],
})
export class AppModule {}

Step 3: Update Your Service Logic

Time to refactor your services. Move from manual ioredis commands to RedisX decorators.

Old School (ioredis):

async getUser(id: string): Promise<User> {
  const cached = await this.redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);
  const user = await this.userRepository.findById(id);
  await this.redis.setex(`user:${id}`, 3600, JSON.stringify(user));
  return user;
}

New Wave (RedisX):

import { Injectable } from '@nestjs/common';
import { Cached } from '@nestjs-redisx/cache';

@Injectable()
export class UserService {
  @Cached({ key: 'user:{0}', ttl: 3600 })
  async getUser(id: string): Promise<User> {
    return this.userRepository.findById(id);
  }
}

Step 4: Distributed Locks Made Easy

Replace any custom locking logic with RedisX's @WithLock decorator. Simplifies your code, adds reliability.

Before:

const lock = await this.redis.set(lockKey, uuid(), 'EX', 30, 'NX');
if (!lock) throw new Error('Lock acquisition failed');
try { await this.doWork(); }
finally { await this.redis.del(lockKey); }

After:

import { WithLock } from '@nestjs-redisx/locks';

@WithLock({ key: 'resource:{0}', ttl: 5000 })
async secureResourceAccess(resourceId: string) {
  await this.doWork(resourceId);
}

Why RedisX?

RedisX is packed with features: L1+L2 caching, distributed locks, rate limiting, and more. It consolidates all Redis functionalities under one roof, making your codebase cleaner, reducing errors, and boosting performance.

For the nitty-gritty details, check out nestjs-redisx.dev.

Embrace RedisX and bring your NestJS architecture into the future. It's not just about making things work—it's about making them work better.

Level Up Your NestJS App with RedisX