import { InjectRedis } from '@liaoliaots/nestjs-redis';
import { Injectable } from '@nestjs/common';
import Redis from 'ioredis';

@Injectable()
export class ThrottlerStorageRedisService {
    scanCount: number;

    constructor(@InjectRedis() private readonly redis: Redis,) {
        this.scanCount = 1000;
    }

    // key를 기반으로 
    async getRecord(key: string): Promise<number[]> {
        const ttls = (
            await this.redis.scan(
                0,
                'MATCH',
                `${this.redis?.options?.keyPrefix}${key}:*`,
                'COUNT',
                this.scanCount,
            )
        ).pop();
        return (ttls as string[]).map((k) => parseInt(k.split(':').pop())).sort();
    }

    async addRecord(key: string, ttl: number): Promise<void> {
        await this.redis.set(`${key}:${Date.now() + ttl * 1000}`, ttl, 'EX', ttl);
    }

}

// throttler.guard.ts
import { ThrottlerGuard } from '@nestjs/throttler';
import { Injectable } from '@nestjs/common';
import * as jwt from 'jsonwebtoken';

@Injectable()
export class ThrottlerBehindProxyGuard extends ThrottlerGuard {
  generateKey(context, prefix) {
    const suffix = `${context.getClass().name}-${context.getHandler().name}`;
    return (`throttle:${suffix}:${prefix}`);
  }
 
  protected getTracker(req: Record<string, any>): string {
    const token = req.headers.authorization
      ? req.headers.authorization.split('Bearer ')[1]
      : '';
    if (token) {
      const decode: any = jwt.verify(
        token,
        process.env.JWT_SECRET,
      )
      return decode.petUserId;
    }

    return req.ips.length ? req.ips[0] : req.ip;
  }
}

import {
  CacheModule,
  MiddlewareConsumer,
  Module,
  NestModule,
} from '@nestjs/common';
import { HttpModule } from '@nestjs/axios';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { WinstonModule } from 'nest-winston';
import { APP_INTERCEPTOR } from '@nestjs/core';
import { ThrottlerModule } from '@nestjs/throttler';
import { TypeOrmModule } from '@nestjs/typeorm';
import Redis from 'ioredis';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { UserModule } from './user/user.module';
import { AuthModule } from './auth/auth.module';
import { AppLoggerMiddleware } from './common/middleware/AppLoggerMiddleware';
import logging from './common/config/logging';
import databaseConfig from './common/config/database';
import { HttpCacheInterceptor } from './common/core/httpcache.interceptor';

@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath: ['.env.local', '.env'],
      isGlobal: true,
      load: [logging, databaseConfig],
    }),
    HttpModule.register({
      timeout: 5000,
      maxRedirects: 5,
    }),
    WinstonModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      useFactory: (configService: ConfigService) =>
        configService.get('logginConfig'),
    }),
    TypeOrmModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      useFactory: (configService: ConfigService) =>
        configService.get('databaseConfig'),
    }),
    CacheModule.register({
      isGlobal: true,
      ttl: 60 * 60
    }),
    // throttlerModue 설정 storage를 reids 기반으로 생성한 service를 사용
    ThrottlerModule.forRoot({
            ttl: 60,
            limit: 30,
            storage: new ThrottlerStorageRedisService(new Redis({
                host: process.env.REDIS_HOST,
                port: +process.env.REDIS_PORT,
            })),
        }),
    UserModule,
    AuthModule,
  ],
  controllers: [AppController],
  providers: [AppService,   {
    // cacheFilter 등록
    provide: APP_INTERCEPTOR,
    useClass: HttpCacheInterceptor,
  },],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer): void {
    consumer.apply(AppLoggerMiddleware).forRoutes('*');
  }
}

// app.controller.ts
  @Post('valid')
  @UseGuards(ThrottlerBehindProxyGuard)
  @Throttle(3, 60)
  testValid(@Body() userDto: UserDto) {
    this.logger.log(userDto);
    // get an environment variable
    const dbUser = this.configService.get<string>('DATABASE_USER');

    // get a custom configuration value
    const dbHost = this.configService.get<string>('DATABASE_PASSWORD');
    return "pass valid! : " + dbUser + "/" + dbHost;
  }

{
  "statusCode": 429,
  "error": "ThrottlerException: Too Many Requests",
  "path": "/valid",
  "method": "POST",
  "timeStamp": "2022-09-16T12:32:23.131Z"
}