# 安装nest cli
npm install -g @nestjs/cli

# 初始化项目
nest new log-metric-agent

# 创建模块
nest g module <module name>

# 为模块创建controller、service
# --no-spec表示不生成.spec.ts文件，
# 这个文件是用于单元测试的。
nest g controller <module name> --no-spec

# 启动
nest start

# 查看依赖
npm ls

@DecoratorName(parameters)

import { Controller, Injectable, Module } from '@nestjs/common';

@Injectable()
export class AppService {}

@Controller()
export class AppController {}

@Module({
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

@Controller('users')
export class UserController {
  @Get()
  getUsers() {
    return 'This returns all users';
  }

  @Post()
  createUser() {
    return 'This creates a user';
  }
}

@Injectable()
export class UserService {
  @Inject('DATABASE_CONNECTION')
  private readonly dbConnection: any;

  findAll() {
    return this.dbConnection.query('SELECT * FROM users');
  }
}

@Controller('users')
export class UserController {
  @Get(':id')
  getUserById(@Param('id') id: string) {
    return `This returns user with id: ${id}`;
  }

  @Post()
  createUser(@Body() body: any) {
    return `This creates a user with data: ${JSON.stringify(body)}`;
  }
}

function MyDecorator(): ClassDecorator {
  return function (target: Function) {
    console.log(`Decorating class: ${target.name}`);
  };
}

@MyDecorator()
class ExampleClass {}

import 'reflect-metadata';

function SetMetadata(key: string, value: any): MethodDecorator {
  return (target, propertyKey, descriptor) => {
    Reflect.defineMetadata(key, value, target, propertyKey);
  };
}

class ExampleClass {
  @SetMetadata('role', 'admin')
  someMethod() {}
}

// 读取元数据
const role = Reflect.getMetadata('role', ExampleClass.prototype, 'someMethod');
console.log(role); // 输出: 'admin'

import { InjectConnection, InjectModel } from "@nestjs/mongoose";
import mongoose, { Connection, Model } from "mongoose";
import { Injectable, Logger } from "@nestjs/common";

@Injectable()
export class TaskService {
    constructor(
        @InjectModel("DagTask") private DagTaskModel: Model<DagTask>,
        @InjectModel(TaskUnit.name) private TaskUnitModel: Model<TaskUnit>,
        @InjectConnection() private connection: Connection
    ) { }

...

}

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

@Module({
  controllers: [CatsController], // 声明该模块管理的 Controller
  providers: [CatsService], // 声明该模块的 Providers（例如 Service 或其他依赖）
  exports: [CatsService], // 允许其他模块使用该模块的 Provider
})
export class CatsModule {}

import { Module } from '@nestjs/common';
import { CatsModule } from './cats/cats.module';

@Module({
  imports: [CatsModule], // 导入其他模块
})
export class AppModule {}

@Module({
  imports: [OtherModule],
})
export class SomeModule {}

@Module({
  controllers: [MyController],
})
export class MyModule {}

@Module({
  providers: [MyService, MyFactory],
})
export class MyModule {}

@Module({
  providers: [MyService],
  exports: [MyService],
})
export class MyModule {}

@Module({})
export class DatabaseModule {
  static forRoot(options: DatabaseOptions): DynamicModule {
    return {
      module: DatabaseModule,
      providers: [
        {
          provide: 'DATABASE_OPTIONS',
          useValue: options,
        },
        DatabaseService,
      ],
      exports: [DatabaseService],
    };
  }
}

@Module({
  imports: [
    DatabaseModule.forRoot({ type: 'mysql', host: 'localhost' }),
  ],
})
export class AppModule {}

import { Global, Module } from '@nestjs/common';

@Global()
@Module({
  providers: [MyGlobalService],
  exports: [MyGlobalService],
})
export class GlobalModule {}

// B.module.ts
@Module({
  providers: [BService],
  exports: [BService],
})
export class BModule {}

// A.module.ts
@Module({
  imports: [BModule], // 导入 BModule
  providers: [AService],
})
export class AModule {}

// 模块A
import { Module, forwardRef } from '@nestjs/common';
import { AService } from './a.service';
import { BModule } from './b.module';

@Module({
  imports: [forwardRef(() => BModule)], // 延迟解析 BModule
  providers: [AService],
  exports: [AService],
})
export class AModule {}

// 模块B
import { Module, forwardRef } from '@nestjs/common';
import { BService } from './b.service';
import { AModule } from './a.module';

@Module({
  imports: [forwardRef(() => AModule)], // 延迟解析 AModule
  providers: [BService],
  exports: [BService],
})
export class BModule {}

import { Injectable, Inject, forwardRef } from '@nestjs/common';
import { BService } from './b.service';

@Injectable()
export class AService {
  constructor(
    @Inject(forwardRef(() => BService)) private readonly bService: BService,
  ) {}

  doSomething() {
    this.bService.someMethod();
  }
}

import { Controller, Get } from '@nestjs/common';

@Controller('users') // 定义基础路由路径为 /users
export class UsersController {
  @Get() // 处理 GET /users 请求
  findAll(): string {
    return 'This action returns all users';
  }
}

import { Controller, Get, Post, Param, Query, Body } from '@nestjs/common';

@Controller('users')
export class UsersController {
  @Get(':id') // 处理 GET /users/:id
  findOne(@Param('id') id: string): string {
    return `This action returns user with ID: ${id}`;
  }

  @Get() // 处理 GET /users?name=John
  findByName(@Query('name') name: string): string {
    return `This action returns user with name: ${name}`;
  }

  @Get("try") // 子路径处理 GET /users/try?name=John
  findByName(@Query('name') name: string): string {
    return `This action returns user with name: ${name}`;
  }

  @Post() // 处理 POST /users
  create(@Body() createUserDto: any): string {
    return `This action creates a user with data: ${JSON.stringify(createUserDto)}`;
  }
}

import { NestFactory } from '@nestjs/core';
import { NestExpressApplication } from '@nestjs/platform-express';
import { AppModule, InternalAppModule } from './app.module';
import { Config } from '@tosee/config';
import { ValidationPipe } from '@nestjs/common';
import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
import { join } from 'path';
import { ValidationError } from 'class-validator';

const extractErrorMessages = (errors: ValidationError[]): string[] => {
  const messages: string[] = [];
  errors.forEach((error) => {
    if (error.constraints) {
      messages.push(...Object.values(error.constraints));
    }
    if (error.children && error.children.length > 0) {
      messages.push(...extractErrorMessages(error.children));
    }
  });
  return messages;
};

// https://www.npmjs.com/package/@tosee/config
async function bootstrap() {
  const app: NestExpressApplication = await NestFactory.create(AppModule);

  if (Config.instance.enableSwagger) {
    const config = new DocumentBuilder()
      .setTitle("LogMetricAgent API")
      .setDescription("LogMetricAgent API文档")
      .setVersion("1.0")
      .addBearerAuth()
      .build();
    const document = SwaggerModule.createDocument(app, config);;
    const swaggerUiPath = join(__dirname, 'swagger-ui');
    const swaggerUiAssets = {
      customJs: [join(swaggerUiPath, 'swagger-ui-bundle.js')],
      customCssUrl: [join(swaggerUiPath, 'swagger-ui.css')],
      customSiteTitle: 'LogMetricAgent API',

    };

    SwaggerModule.setup("/api/log-metric-agent/api-doc", app, document, {
      customSiteTitle: swaggerUiAssets.customSiteTitle,
      customJs: swaggerUiAssets.customJs,
      customCssUrl: swaggerUiAssets.customCssUrl,
    });
    app.useStaticAssets(join(__dirname, "swagger-ui"), {
      prefix: "/api/log-metric-agent/api-doc"
    });
  }

  app.useGlobalInterceptors(new RequestInterceptor());
  app.useGlobalFilters(new HttpExceptionFilter());
  app.useGlobalPipes(new ValidationPipe({
    transform: true, // 很重要
    exceptionFactory: (errors: ValidationError[]) => {
      // 这里对errors的解析也很重要
      const errorMessages = extractErrorMessages(errors);
      return new Exception(ResponseCode.ParamsError, `${errorMessages}`, null);
    }
  }));
  await app.listen(9999);
}
bootstrap();

import { Injectable } from '@nestjs/common';

@Injectable()
export class MyService {
  getHello(): string {
    return 'Hello World!';
  }
}

import { Module } from '@nestjs/common';
import { MyService } from './my.service';

@Module({
  providers: [MyService], // 注册 MyService 作为 Provider
})
export class AppModule {}

import { Injectable } from '@nestjs/common';
import { MyService } from './my.service';

@Injectable()
export class AppService {
  constructor(private readonly myService: MyService) {} // 注入 MyService

  getGreeting(): string {
    return this.myService.getHello();
  }
}

@Module({
  providers: [MyService],
})

@Module({
  providers: [
    {
      provide: 'API_KEY',
      useValue: '123456', // 提供静态值
    },
  ],
})

@Injectable()
export class AppService {
  constructor(@Inject('API_KEY') private readonly apiKey: string) {}

  getApiKey(): string {
    return this.apiKey;
  }
}

@Module({
  providers: [
    {
      provide: 'CONFIG',
      useFactory: () => {
        return { appName: 'MyApp', version: '1.0.0' };
      },
    },
  ],
})

@Injectable()
export class ConfigService {
  constructor(@Inject('CONFIG') private readonly config: any) {}

  getConfig(): any {
    return this.config;
  }
}

@Module({
  providers: [
    MyService,
    {
      provide: 'AliasForMyService',
      useExisting: MyService, // 指向 MyService
    },
  ],
})

@Module({})
export class ConfigModule {
  static forRoot(config: any): DynamicModule {
    return {
      module: ConfigModule,
      providers: [
        {
          provide: 'CONFIG',
          useValue: config,
        },
      ],
      exports: ['CONFIG'],
    };
  }
}

import { Injectable, Logger } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { Task, TaskDocument } from './schemas/task.schema';
import { CreateTaskDto } from './dto/create-task.dto';
import { UpdateTaskDto } from './dto/update-task.dto';

@Injectable()
export class TasksService {
  private readonly logger = new Logger(TasksService.name);

  constructor(
    @InjectModel(Task.name) private taskModel: Model<TaskDocument>,
  ) { }

  async createTask(createTaskDto: CreateTaskDto): Promise<Task> {
    this.logger.log(`Creating a new task: ${JSON.stringify(createTaskDto)}`);
    const createdTask = new this.taskModel(createTaskDto);
    return createdTask.save();
  }

  async getAllTasks(): Promise<Task[]> {
    this.logger.log('Fetching all tasks');
    return this.taskModel.find().exec();
  }

  async getTaskById(id: string): Promise<Task> {
    this.logger.log(`Fetching task by ID: ${id}`);
    return this.taskModel.findById(id).exec();
  }

  async updateTask(id: string, updateTaskDto: UpdateTaskDto): Promise<Task> {
    this.logger.log(`Updating task with ID: ${id}`);
    return this.taskModel
      .findByIdAndUpdate(id, updateTaskDto, { new: true })
      .exec();
  }

  async deleteTask(id: string): Promise<Task> {
    this.logger.log(`Deleting task with ID: ${id}`);
    return this.taskModel.findByIdAndDelete(id).exec();
  }
}

import { IsNotEmpty, IsString, IsOptional } from 'class-validator';

export class CreateTaskDto {
	@IsNotEmpty()
    @IsString()
    title: string;

    @IsOptional()
    @IsString()
    description?: string;
}

import { IsString, IsOptional, IsBoolean } from 'class-validator';

export class UpdateTaskDto {
    @IsOptional()
    @IsString()
    title?: string;
    
    @IsOptional()
    @IsString()
    description?: string;
    
    @IsOptional()
    @IsBoolean()
    completed?: boolean
}

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { TasksService } from './tasks.service';
import { Task, TaskSchema } from './schemas/task.schema';

@Module({
	imports: [MongooseModule.forFeature([{ name: Task.name, schema: TaskSchema }])],
	providers: [TasksService],
	exports: [TasksService],
})
export class TasksModule {}

intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
  console.log('在机器启动前...');
  const productConveyorBelt = next.handle(); // 拿到传送带
  // ...此时机器还未生产，但传送带已经准备好了
  return productConveyorBelt; // 把传送带交给 NestJS 框架
}

return next.handle().pipe(
  // 在这里安装处理站...
  station1,
  station2,
  station3
);

// ...
return next.handle().pipe(
  tap(product => {
    // 我是质检员
    console.log(`质检站：看到一个产品！产品是:`, product);
    // 我只是记录了一下，没有对 product 做任何修改
  })
);

// TransformInterceptor
return next.handle().pipe(
  map(product => {
    // 我是加工站
    console.log('正在把产品包装一下...');
    // 返回一个全新的对象
    return { data: product, code: 200 }; 
  })
);

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    console.log('1. 拦截器前置部分：准备启动生产机器...');
    const now = Date.now();

    // 2. 调用 next.handle()，拿到“未来的产品传送带”
    //    并用 .pipe() 在上面安装一个“质检站” (tap)
    return next.handle().pipe(
      
      // 4. 当产品从生产机器出来，流到这里时...
      tap((data) => {
        console.log(`5. 质检站 (tap) 开始工作！`);
        console.log(`   - 产品数据是: ${JSON.stringify(data)}`);
        console.log(`   - 生产耗时: ${Date.now() - now}ms`);
        // tap 不会修改 data，它会把原始 data 继续传下去
      })
    );
    
    // 3. Controller 方法在这里被“懒执行”
    //    当 NestJS 订阅这个返回的 Observable 时，
    //    Controller 方法才真正执行，并把返回值作为“产品”放到传送带上。
  }
}

import { NestFactory } from "@nestjs/core";
import { MiscLogger } from "src/utils/logger";
import { MQAppModule } from './mq-app.module';
import { Transport } from "@nestjs/microservices";

async function bootstrap() {
  const logger_impl = new MiscLogger();
  const app = await NestFactory.createMicroservice(MQAppModule, {
    transport: Transport.RMQ,
    options: {
      urls: ["amqp://admin:xxxxxxxx@pro-mq-dev.deeplive.com:5672"],
      queue: "kaihang-playground-queue",
      queueOptions: {
        durable: false,
      },
      noAck: false, // noAck可以理解为不用用户Ack，也就是如果noAck是true的话，不用用户发送ack，也就是自动确认，noAck是false的话，表示用户要发送ack，noAck: false的情况才能够手动调用ack和nack
    }
  });
  app.useLogger(logger_impl);
  app.listen();
}

bootstrap();

import { forwardRef, Module } from "@nestjs/common";
import { RateLimiterModule } from "nest-ratelimiter";
import { RedisModule } from "src/redis/redis.module";
import { RedisService } from "src/redis/redis.service";
import { MQAppController } from "./mq-app.controller";

@Module({
  imports: [
      RedisModule.forRoot({
        host: "192.168.0.211",
        port: 6379,
        password: "",
        db: 0
      }),
      RateLimiterModule.forRootAsync({
        imports: [RedisModule],
        inject: [RedisService],
        useFactory: async (redisService: RedisService) => ({
          db: redisService.getClient()
        })
      })
    ],
    controllers: [MQAppController],
    providers: [],
    exports: []
})
export class MQAppModule{}

import { Controller, Inject } from "@nestjs/common";
import { Ctx, EventPattern, Payload, RmqContext } from "@nestjs/microservices";
import { RATE_LIMITER_ASSERTER_TOKEN, RateLimiterAsserter } from "nest-ratelimiter";

@Controller()
export class MQAppController {
  constructor(
    @Inject(RATE_LIMITER_ASSERTER_TOKEN) private readonly rateLimiterAsserter: RateLimiterAsserter,
  ) {}

  @EventPattern("uacktesting.start")
  async testNACK(@Payload() data: any, @Ctx() context: RmqContext) {
    console.log(`Received data: ${JSON.stringify(data)}, and going to call nack`);
    const sourceMsg = context.getMessage();
    const channel = context.getChannelRef();
    channel.nack(sourceMsg, false, true);
  }
}

# 这个库是目前最符合需求的，超限之后不会刷新时间窗口（导致高频请求永远被禁止）
npm install rate-limiter-flexible

import { Inject, Injectable, Logger } from "@nestjs/common";
import Redis from "ioredis";
import { RateLimiterRedis } from "rate-limiter-flexible";
import { RedisService } from "src/redis/redis.service";

export interface RateLimitOptProps {
  points: number, // number of points
  duration: number, // Per second
  keyPrefix: string, // must be unique for limiters with different purpose
}

export class RateLimitExceededError extends Error {
  constructor(
    message: string,
    public readonly remainingPoints: number,
    public readonly msBeforeNext: number,
    public readonly consumedPoints: number,
    public readonly isFirstInDuration: boolean
  ) {
    super(message);
  }
}

@Injectable()
export class RateLimiterService {
  private readonly logger = new Logger(RateLimiterService.name);
  private limiterMap: Record<string, RateLimiterRedis> = {};

  constructor(private readonly redisService: RedisService) {}

  async limit(options: RateLimitOptProps, key: string) {
    if (!(options.keyPrefix in this.limiterMap)) {
      this.limiterMap[options.keyPrefix] = new RateLimiterRedis({
        storeClient: this.redisService.getClient(),
        blockDuration: 0, // no block if consumed more than points.
        ...options
      });
    }

    try {
      return await this.limiterMap[options.keyPrefix].consume(key);
    } catch(err) {
      if (![err.remainingPoints, err.msBeforeNext, err.consumedPoints, err.isFirstInDuration].includes(undefined)) {
        throw new RateLimitExceededError(
          `${key}调用频率超限：${JSON.stringify(options)}`,
          err.remainingPoints,
          err.msBeforeNext,
          err.consumedPoints,
          err.isFirstInDuration);
      } else {
        throw err;
      }
    }
  }
}

import { Controller, Inject } from "@nestjs/common";
import { Ctx, EventPattern, Payload, RmqContext } from "@nestjs/microservices";
import { RateLimiterService, RateLimitExceededError } from "./ratelimiter.service";

@Controller()
export class MQAppController {
  constructor(
    private readonly rateLimiterService: RateLimiterService
  ) {}

  @EventPattern("uacktesting.start")
  async testNACK(@Payload() data: any, @Ctx() context: RmqContext) {
    const sourceMsg = context.getMessage();
    const channel = context.getChannelRef();

    try {
      const res = await this.rateLimiterService.limit({
        points: 2,
        duration: 10, // second
        keyPrefix: "MQAppController"
      }, "uacktesting.start");
      console.log("consumed：", data, res);
      channel.ack(sourceMsg);
    } catch(err) {
      if (err instanceof RateLimitExceededError) {
        const timeOut = err.msBeforeNext + 2 * err.consumedPoints; // 延迟后续到达的请求
        console.log(`调用频率超限，${timeOut}ms后重新归队。`);
        setTimeout(() => {
          channel.nack(sourceMsg, false, true);
        }, timeOut); // 延迟回队，等待后续重试
      } else {
        console.error(err);
        // TODO：这里任务失败返回失败原因，并且直接ack
        channel.ack(sourceMsg);
      }
    }
  }
}