[BE] redis를 사용해 최근 검색어 저장

BE/package.json

@@ -43,6 +43,7 @@
     "dotenv": "^16.4.5",
     "express": "^4.21.1",
     "fastify-swagger": "^5.1.1",
+    "ioredis": "^5.4.1",
     "mysql2": "^3.11.3",
     "passport": "^0.7.0",
     "passport-jwt": "^4.0.1",

BE/src/app.module.ts

@@ -14,6 +14,7 @@ import { StockDetailModule } from './stock/detail/stock-detail.module';
 import { typeOrmConfig } from './configs/typeorm.config';
 import { StockListModule } from './stock/list/stock-list.module';
 import { StockTradeHistoryModule } from './stock/trade/history/stock-trade-history.module';
+import { RedisModule } from './common/redis/redis.module';
 
 @Module({
   imports: [
@@ -29,6 +30,7 @@ import { StockTradeHistoryModule } from './stock/trade/history/stock-trade-histo
     StockOrderModule,
     StockListModule,
     StockTradeHistoryModule,
+    RedisModule,
   ],
   controllers: [AppController],
   providers: [AppService],

BE/src/auth/strategy/jwt.strategy.ts

@@ -23,6 +23,11 @@ export class JwtStrategy extends PassportStrategy(Strategy) {
     const user: User = await this.userRepository.findOne({ where: { email } });
     if (!user) throw new UnauthorizedException();
 
-    return user;
+    return {
+      userId: user.id,
+      email: user.email,
+      tutorial: user.tutorial,
+      kakaoId: user.kakaoId,
+    };
   }
 }

BE/src/common/redis/redis.domain-service.ts

@@ -0,0 +1,57 @@
+import { Injectable, Inject } from '@nestjs/common';
+import Redis from 'ioredis';
+
+@Injectable()
+export class RedisDomainService {
+  constructor(
+    @Inject('REDIS_CLIENT')
+    private readonly redis: Redis,
+  ) {}
+
+  async get(key: string): Promise<string | null> {
+    return this.redis.get(key);
+  }
+
+  async set(key: string, value: string, expires?: number): Promise<'OK'> {
+    if (expires) {
+      return this.redis.set(key, value, 'EX', expires);
+    }
+    return this.redis.set(key, value);
+  }
+
+  async del(key: string): Promise<number> {
+    return this.redis.del(key);
+  }
+
+  async zadd(key: string, score: number, member: string): Promise<number> {
+    return this.redis.zadd(key, score, member);
+  }
+
+  async zcard(key: string): Promise<number> {
+    return this.redis.zcard(key);
+  }
+
+  async zrange(key: string, start: number, stop: number): Promise<string[]> {
+    return this.redis.zrange(key, start, stop);
+  }
+
+  async zremrangebyrank(
+    key: string,
+    start: number,
+    stop: number,
+  ): Promise<number> {
+    return this.redis.zremrangebyrank(key, start, stop);
+  }
+
+  async zrevrange(key: string, start: number, stop: number): Promise<string[]> {
+    return this.redis.zrevrange(key, start, stop);
+  }
+
+  async zrem(key: string, member: string): Promise<number> {
+    return this.redis.zrem(key, member);
+  }
+
+  async expire(key: string, seconds: number): Promise<number> {
+    return this.redis.expire(key, seconds);
+  }
+}

BE/src/common/redis/redis.module.ts

@@ -0,0 +1,22 @@
+// src/common/redis/redis.module.ts
+import { Global, Module } from '@nestjs/common';
+import Redis from 'ioredis';
+import { RedisDomainService } from './redis.domain-service';
+
+@Global()
+@Module({
+  providers: [
+    {
+      provide: 'REDIS_CLIENT',
+      useFactory: () => {
+        return new Redis({
+          host: process.env.REDIS_HOST,
+          port: Number(process.env.REDIS_PORT),
+        });
+      },
+    },
+    RedisDomainService,
+  ],
+  exports: [RedisDomainService, 'REDIS_CLIENT'],
+})
+export class RedisModule {}

BE/src/common/redis/redis.provider.ts

@@ -0,0 +1,14 @@
+import { Provider } from '@nestjs/common';
+import Redis from 'ioredis';
+import dotenv from 'dotenv';
+
+dotenv.config();
+export const RedisProvider: Provider = {
+  provide: 'REDIS_CLIENT',
+  useFactory: () => {
+    return new Redis({
+      host: process.env.REDIS_HOST,
+      port: Number(process.env.REDIS_PORT),
+    });
+  },
+};

BE/src/stock/list/interface/search-params.interface.ts

@@ -2,4 +2,5 @@ export interface SearchParams {
   name?: string;
   market?: string;
   code?: string;
+  userId: number;
 }

BE/src/stock/list/stock-list.controller.ts

@@ -1,5 +1,7 @@
-import { Controller, Get, Query } from '@nestjs/common';
+import { Controller, Get, Query, Req, UseGuards } from '@nestjs/common';
 import { ApiOperation, ApiQuery, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { Request } from 'express';
+import { JwtAuthGuard } from 'src/auth/jwt-auth-guard';
 import { StockListService } from './stock-list.service';
 import { StockListResponseDto } from './dto/stock-list-response.dto';
 
@@ -32,12 +34,15 @@ export class StockListController {
   @ApiQuery({ name: 'market', required: false })
   @ApiQuery({ name: 'code', required: false })
   @Get('/search')
+  @UseGuards(JwtAuthGuard)
   async searchWithQuery(
+    @Req() req: Request,
     @Query('name') name?: string,
     @Query('market') market?: string,
     @Query('code') code?: string,
   ): Promise<StockListResponseDto[]> {
-    return this.stockListService.search({ name, market, code });
+    const userId = parseInt(req.user.userId, 10);
+    return this.stockListService.search({ name, market, code, userId });
   }
 
   @ApiOperation({

BE/src/stock/list/stock-list.module.ts

@@ -1,14 +1,16 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
+import { RedisDomainService } from 'src/common/redis/redis.domain-service';
+import { RedisModule } from 'src/common/redis/redis.module';
 import { StockListRepository } from './stock-list.repostiory';
 import { StockListService } from './stock-list.service';
 import { StockListController } from './stock-list.controller';
 import { Stocks } from './stock-list.entity';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Stocks])],
+  imports: [TypeOrmModule.forFeature([Stocks]), RedisModule],
   controllers: [StockListController],
-  providers: [StockListRepository, StockListService],
+  providers: [StockListRepository, StockListService, RedisDomainService],
   exports: [],
 })
 export class StockListModule {}

BE/src/stock/list/stock-list.service.ts

@@ -1,12 +1,18 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
+import { RedisDomainService } from 'src/common/redis/redis.domain-service';
 import { StockListRepository } from './stock-list.repostiory';
 import { Stocks } from './stock-list.entity';
 import { StockListResponseDto } from './dto/stock-list-response.dto';
 import { SearchParams } from './interface/search-params.interface';
 
 @Injectable()
 export class StockListService {
-  constructor(private readonly stockListRepository: StockListRepository) {}
+  private readonly SearchHistoryLimit = 10;
+
+  constructor(
+    private readonly stockListRepository: StockListRepository,
+    private readonly redisDomainService: RedisDomainService,
+  ) {}
 
   private toResponseDto(stock: Stocks): StockListResponseDto {
     return new StockListResponseDto(stock.code, stock.name, stock.market);
@@ -27,7 +33,24 @@ export class StockListService {
   }
 
   async search(params: SearchParams): Promise<StockListResponseDto[]> {
+    await this.addSearchTermToRedis(params);
     const stocks = await this.stockListRepository.search(params);
     return stocks.map((stock) => this.toResponseDto(stock));
   }
+
+  async addSearchTermToRedis(params: SearchParams) {
+    const key = `search:${params.userId}`;
+    const timeStamp = Date.now();
+
+    const { name, market, code } = params;
+
+    const searchTerm = name || market || code;
+
+    await this.redisDomainService.zadd(key, timeStamp, searchTerm);
+
+    const searchHistoryCount = await this.redisDomainService.zcard(key);
+    if (searchHistoryCount > this.SearchHistoryLimit) {
+      await this.redisDomainService.zremrangebyrank(key, 0, 0);
+    }
+  }
 }