Vòng đời NestJS. 1 Khái niệm quan trọng cần nắm trong framework con mèo!

import { Logger } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { Request, Response, NextFunction } from 'express';
import helmet from 'helmet';
import { AppModule } from './app.module';
// Bootstrap mang ý nghĩa là hàm bắt đầu
async function bootstrap() {
  const logger = new Logger(bootstrap.name);
  const app = await NestFactory.create(AppModule);
  // NOTICE: GLOBAL MIDDLEWARE
  app.use(helmet());
  // Custom middlware here!
  app.use((req: Request, res: Response, next: NextFunction) => {
    logger.debug('===TRIGGER GLOBAL MIDDLEWARE===');
    next();
  });
  await app.listen(3000);
}
bootstrap();

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

@Injectable()
export class VersionMiddleware implements NestMiddleware {
  logger = new Logger(VersionMiddleware.name);
  use(req: Request, res: Response, next: NextFunction) {
    // NOTICE: MODULE BOUND MIDDLEWARE
    this.logger.debug('===TRIGGER MODULE BOUND MIDDLEWARE===');
    const appVersion = req.headers['x-app-version'];
    if (!appVersion || appVersion !== '2.0.0')
      throw new BadRequestException('Invalid App Version');
    next();
  }
}

import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { VersionMiddleware } from './middlewares/version.middleware';
import { FlashCardsModule } from './modules/flash-cards/flash-cards.module';

@Module({
  imports: [FlashCardsModule],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(VersionMiddleware).forRoutes('flash-cards');
  }
}

...
@Module({
  imports: [
    ThrottlerModule.forRoot({
      ttl: 60,
      limit: 10, // Giới hạn số request có thể truy cập trong thời gian ttl
    }),
    ...
  ],
})
export class AppModule {}

import { ExecutionContext, Logger } from '@nestjs/common';
import { ThrottlerGuard } from '@nestjs/throttler';
// Tạo một custom kế thừa từ ThrottlerGuard global
export class CustomThrottlerGuard extends ThrottlerGuard {
  logger = new Logger(CustomThrottlerGuard.name);
  canActivate(context: ExecutionContext): Promise<boolean> {
    this.logger.log('===TRIGGER GLOBAL GUARD===');
    return super.canActivate(context);
  }
}

...
@Module({
  imports: [
    ThrottlerModule.forRoot({
      ttl: 60,
      limit: 10,
    }),
    FlashCardsModule,
  ],
  controllers: [AppController],
  providers: [
    AppService,
    {
      provide: APP_GUARD,
      useClass: CustomThrottlerGuard,
    },
  ],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(VersionMiddleware).forRoutes('flash-cards');
  }
}

import {
  Injectable,
  CanActivate,
  ExecutionContext,
  Logger,
} from '@nestjs/common';
import { Observable } from 'rxjs';

@Injectable()
export class JwtAuthorizationGuard implements CanActivate {
  logger = new Logger(JwtAuthorizationGuard.name);
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    // NOTICE: CONTROLLER GUARD
    this.logger.log('===TRIGGER CONTROLLER GUARD===');
    // IMPLEMENT JWT GUARD LOGIC HERE
    return true;
  }
}

...
@UseGuards(JwtAuthorizationGuard) // Sử dụng Guard JWT ở đây!
@Controller('flash-cards')
export class FlashCardsController {
  constructor(private readonly flashCardsService: FlashCardsService) {}

  @Get()
  async findAll() {
    return await this.flashCardsService.findAll();
  }
  ...

import {
  Injectable,
  CanActivate,
  ExecutionContext,
  Logger,
} from '@nestjs/common';
import { Observable } from 'rxjs';

@Injectable()
export class OwnershipGuard implements CanActivate {
  logger = new Logger(OwnershipGuard.name);
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    // NOTICE: ROUTE GUARD
    this.logger.log('===TRIGGER ROUTE GUARD===');
    // IMPLEMENT QUERY FLASH-CARD DATA AND CHECK OWNERSHIP
    return true;
  }
}

...
  @Patch(':id')
  @UseGuards(OwnershipGuard)
  update(
    @Param('id') id: string,
    @Body() updateFlashCardDto: UpdateFlashCardDto,
  ) {
    return this.flashCardsService.update(+id, updateFlashCardDto);
  }
  ```

import {
  Injectable,
  NestInterceptor,
  ExecutionContext,
  CallHandler,
  Logger,
} from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  logger = new Logger(LoggingInterceptor.name);
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    // NOTICE: GLOBAL INTERCEPTOR
    this.logger.warn('===TRIGGER GLOBAL INTERCEPTOR (PRE)===');

    const now = Date.now();
    return next.handle().pipe(
      tap(() => {
        logger.log(`After... ${Date.now() - now}ms`);
        // NOTICE: GLOBAL INTERCEPTOR
        this.logger.warn('===TRIGGER GLOBAL INTERCEPTOR (POST)===');
      }),
    );
  }
}

import { LoggingInterceptor } from './interceptors/logging.interceptor';
...
async function bootstrap() {
  const logger = new Logger(bootstrap.name);
  const app = await NestFactory.create(AppModule);
  // Thêm vào đây
  app.useGlobalInterceptors(new LoggingInterceptor());
  // NOTICE: GLOBAL MIDDLEWARE
  app.use(helmet());
  app.use((req: Request, res: Response, next) => {
    logger.debug('===TRIGGER GLOBAL MIDDLEWARE===');
    next();
  });
  await app.listen(3000);
}
bootstrap();

import {
  ArgumentMetadata,
  Injectable,
  Logger,
  PipeTransform,
} from '@nestjs/common';

@Injectable()
export class ParseControllerValidationPipe implements PipeTransform<string> {
  logger = new Logger(ParseControllerValidationPipe.name);
  transform(value: string, metadata: ArgumentMetadata): string {
    // NOTICE: CONTROLLER PIPE
    this.logger.verbose('===TRIGGER CONTROLLER PIPE===');
    return value;
  }
}

import { ParseControllerValidationPipe } from 'src/pipes/parse-custom-validation-controller.pipe';
...
@UseInterceptors(TimeoutInterceptor)
@UseGuards(JwtAuthorizationGuard)
@UsePipes(ParseControllerValidationPipe)
@Controller('flash-cards')
export class FlashCardsController {
...
}

import {
  ArgumentMetadata,
  Injectable,
  Logger,
  PipeTransform,
} from '@nestjs/common';

@Injectable()
export class ParseRouteValidationPipe implements PipeTransform<string> {
  logger = new Logger(ParseRouteValidationPipe.name);
  transform(value: string, metadata: ArgumentMetadata): string {
    // NOTICE: ROUTE PIPE
    this.logger.verbose('===TRIGGER ROUTE PIPE===');
    return value;
  }
}

import { ParseRouteValidationPipe } from 'src/pipes/parse-custom-route-validation.pipe';
...
@Get()
@UseGuards(OwnershipGuard)
@UseInterceptors(ExcludeNullInterceptor)
@UsePipes(ParseRouteValidationPipe)
async findAll(@Query('limit') limit) {
    this.logger.log(`Method name: ${this.findAll.name}`);
    return await this.flashCardsService.findAll();
}
...

import {
  ArgumentMetadata,
  BadRequestException,
  Injectable,
  Logger,
  PipeTransform,
} from '@nestjs/common';
import { isObjectIdOrHexString } from 'mongoose';

@Injectable()
export class ParseMongoIdPipe implements PipeTransform<string> {
  logger = new Logger(ParseMongoIdPipe.name);
  transform(value: string, metadata: ArgumentMetadata): string {
    // NOTICE: ROUTE PIPE
    this.logger.log('===TRIGGER ROUTE PARAMS PIPE===');
    if (!isObjectIdOrHexString(value)) {
      throw new BadRequestException('Invalid ID');
    }
    return value;
  }
}

import { ParseMongoIdPipe } from 'src/pipes/parse-mongo-id.pipe';
import { ObjectId } from 'mongoose';
...
@Get(':id')
@UseInterceptors(ExcludeNullInterceptor)
findOne(@Param('id', ParseMongoIdPipe) id: ObjectId) {
    return this.flashCardsService.findOne(id);
}
  ...