NestJS and Redis Integration Guide

NestJS is a progressive Node.js framework designed for building efficient, reliable, and scalable server-side applications. By leveraging TypeScript and combining elements of object-oriented programming, functional programming, and functional reactive programming, NestJS offers a robust architecture for modern applications. Integrating Redis, a high-performance in-memory data store, can significantly enhance the performance of NestJS applications. This article provides a detailed guide on how to implement Redis in a NestJS application.

Why Integrate Redis with NestJS?

Combining Redis with NestJS brings several benefits:

Caching: Redis can cache frequently accessed data, reducing load on databases and improving response times.
Session Management: Redis is often used to store session data, providing fast access and persistence.
Pub/Sub Messaging: Redis's publish/subscribe capabilities enable efficient real-time messaging.
Data Structures: Redis supports various data structures, such as strings, lists, sets, hashes, and more, making it versatile for different use cases.

Setting Up Redis with NestJS

Prerequisites

Node.js and npm installed
NestJS CLI installed (npm install -g @nestjs/cli)
Redis server installed and running

Create a New NestJS Project

Start by creating a new NestJS project:

nest new my-nest-redis-app
cd my-nest-redis-app

Install Redis and Required Packages

Install the redis package and @nestjs/redis for Redis integration:

npm install redis @nestjs/redis

Configure Redis in NestJS

Create a configuration for Redis. This can be done in a dedicated configuration file.

Create a Redis Module:

Generate a new module for Redis:
```
 nest generate module redis
```

Configure the Redis Module:

Create a configuration for connecting to Redis in src/redis/redis.module.ts:

 import { Module } from '@nestjs/common';
 import { RedisModule } from '@nestjs/redis';

 @Module({
   imports: [
     RedisModule.forRoot({
       url: 'redis://localhost:6379',
     }),
   ],
 })
 export class CustomRedisModule {}

Inject Redis Client

To use the Redis client in your services, inject it using the @InjectRedis() decorator provided by @nestjs/redis.

Create a Service:

Generate a new service:
```
 nest generate service redis
```

Inject Redis Client in the Service:

Use the @InjectRedis() decorator to inject the Redis client in src/redis/redis.service.ts:

 import { Injectable } from '@nestjs/common';
 import { InjectRedis, Redis } from '@nestjs/redis';

 @Injectable()
 export class RedisService {
   constructor(@InjectRedis() private readonly redisClient: Redis) {}

   async setValue(key: string, value: string): Promise<void> {
     await this.redisClient.set(key, value);
   }

   async getValue(key: string): Promise<string> {
     return await this.redisClient.get(key);
   }
 }

Using Redis Service in a Controller

Create a controller to use the Redis service:

Generate a Controller:
```
 nest generate controller redis
```

Use the Redis Service in the Controller:

Inject and use the Redis service in src/redis/redis.controller.ts:

 import { Controller, Get, Param, Post, Body } from '@nestjs/common';
 import { RedisService } from './redis.service';

 @Controller('redis')
 export class RedisController {
   constructor(private readonly redisService: RedisService) {}

   @Post('set')
   async setKey(@Body('key') key: string, @Body('value') value: string) {
     await this.redisService.setValue(key, value);
     return 'Key set successfully';
   }

   @Get('get/:key')
   async getKey(@Param('key') key: string) {
     const value = await this.redisService.getValue(key);
     return value ? { key, value } : { message: 'Key not found' };
   }
 }

Complete Example

Here's a complete example, integrating the steps above:

src/redis/redis.module.ts:

import { Module } from '@nestjs/common';
import { RedisModule } from '@nestjs/redis';
import { RedisService } from './redis.service';
import { RedisController } from './redis.controller';

@Module({
  imports: [
    RedisModule.forRoot({
      url: 'redis://localhost:6379',
    }),
  ],
  providers: [RedisService],
  controllers: [RedisController],
})
export class CustomRedisModule {}

src/redis/redis.service.ts:

import { Injectable } from '@nestjs/common';
import { InjectRedis, Redis } from '@nestjs/redis';

@Injectable()
export class RedisService {
  constructor(@InjectRedis() private readonly redisClient: Redis) {}

  async setValue(key: string, value: string): Promise<void> {
    await this.redisClient.set(key, value);
  }

  async getValue(key: string): Promise<string> {
    return await this.redisClient.get(key);
  }
}

src/redis/redis.controller.ts:

import { Controller, Get, Param, Post, Body } from '@nestjs/common';
import { RedisService } from './redis.service';

@Controller('redis')
export class RedisController {
  constructor(private readonly redisService: RedisService) {}

  @Post('set')
  async setKey(@Body('key') key: string, @Body('value') value: string) {
    await this.redisService.setValue(key, value);
    return 'Key set successfully';
  }

  @Get('get/:key')
  async getKey(@Param('key') key: string) {
    const value = await this.redisService.getValue(key);
    return value ? { key, value } : { message: 'Key not found' };
  }
}

src/app.module.ts:

import { Module } from '@nestjs/common';
import { CustomRedisModule } from './redis/redis.module';

@Module({
  imports: [CustomRedisModule],
})
export class AppModule {}

Running the Application

Start the NestJS application:

npm run start

Test the Redis integration by setting and getting keys via the provided endpoints:

Set a Key:

 curl -X POST http://localhost:3000/redis/set -d '{"key":"testKey","value":"testValue"}' -H "Content-Type: application/json"

Get a Key:

 curl http://localhost:3000/redis/get/testKey

Conclusion

Integrating Redis with NestJS enhances the performance and scalability of your application by providing powerful features such as caching, session management, and real-time messaging. By following this guide, you can seamlessly integrate Redis into your NestJS application, leveraging its capabilities to build robust and efficient server-side solutions.

Integrating Redis with NestJS: A Comprehensive Guide

Table of contents