Nest

async function bootstrap() {
  // Tạo ứng dụng với platform Express (mặc định)
  const app = await NestFactory.create(AppModule);

  // Hoặc dùng Fastify để có performance cao hơn
  const app = await NestFactory.create<NestFastifyApplication>(
    AppModule,
    new FastifyAdapter(),
  );

  // Cấu hình global trước khi listen
  app.setGlobalPrefix("api/v1");
  app.useGlobalPipes(new ValidationPipe({ whitelist: true, transform: true }));
  app.useGlobalFilters(new HttpExceptionFilter());
  app.enableCors({ origin: process.env.ALLOWED_ORIGINS?.split(",") });

  await app.listen(3000);
  console.log(`Application running on: ${await app.getUrl()}`);
}
bootstrap();

// ❌ KHÔNG NÊN — mất interceptor, mất NestJS response handling
@Get('users')
getUsers(@Res() res: Response) {
  const users = this.userService.findAll();
  res.status(200).json(users); // thủ công, interceptor không chạy
}

// ✅ NÊN — để NestJS xử lý
@Get('users')
getUsers() {
  return this.userService.findAll(); // interceptor vẫn chạy, serialize tự động
}

// ✅ Trường hợp PHẢI dùng @Res — stream file
@Get('download/:filename')
downloadFile(@Param('filename') filename: string, @Res() res: Response) {
  const filePath = path.join(process.cwd(), 'uploads', filename);
  res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
  createReadStream(filePath).pipe(res);
}

// ✅ Trường hợp PHẢI dùng @Res — set cookie
@Post('login')
async login(@Body() dto: LoginDto, @Res({ passthrough: true }) res: Response) {
  const token = await this.authService.login(dto);
  res.cookie('access_token', token, { httpOnly: true, secure: true });
  return { message: 'Logged in successfully' }; // vẫn return để interceptor chạy
}

import { HttpCode, HttpStatus } from '@nestjs/common';

// Override POST từ 201 xuống 200 — dùng khi POST không tạo resource
// mà chỉ thực hiện một action (ví dụ: POST /auth/logout)
@Post('logout')
@HttpCode(HttpStatus.OK) // 200 thay vì 201
async logout(@CurrentUser() user: UserEntity) {
  await this.authService.invalidateToken(user.id);
  return { message: 'Logged out' };
}

// DELETE thường trả về 204 No Content (không có body)
@Delete(':id')
@HttpCode(HttpStatus.NO_CONTENT) // 204
async remove(@Param('id') id: string) {
  await this.userService.remove(id);
  // không return gì — body rỗng, phù hợp với 204
}

// Accepted — dùng khi action được nhận nhưng chưa hoàn thành (async job)
@Post('export')
@HttpCode(HttpStatus.ACCEPTED) // 202
async requestExport(@Body() dto: ExportDto) {
  const jobId = await this.exportService.enqueue(dto);
  return { jobId }; // client sẽ poll để check trạng thái
}

// Cả 3 cách đều hoạt động, NestJS xử lý đồng nhất

// 1. Sync — return trực tiếp
@Get('sync')
getSync(): string {
  return 'Hello'; // NestJS gửi ngay
}

// 2. Async/Promise
@Get('async')
async getAsync(): Promise<UserDto> {
  return this.userService.findOne(id); // NestJS await Promise rồi gửi
}

// 3. Observable — thường thấy khi dùng NestJS Microservice hoặc RxJS operators
@Get('observable')
getObservable(): Observable<UserDto> {
  return from(this.userService.findOne(id)).pipe(
    map(user => plainToInstance(UserDto, user)),
    timeout(5000), // tự động timeout sau 5 giây
    catchError(err => throwError(() => new InternalServerErrorException()))
  );
  // NestJS subscribe, lấy giá trị đầu tiên, unsubscribe
}

@Module({
  providers: [
    // 1. Class provider (cách viết tắt, phổ biến nhất)
    UserService,
    // Tương đương với:
    { provide: UserService, useClass: UserService },

    // 2. Value provider — inject một giá trị cố định, không phải instance
    { provide: "JWT_SECRET", useValue: process.env.JWT_SECRET },
    { provide: "APP_CONFIG", useValue: { maxUploadSize: 10 * 1024 * 1024 } },

    // 3. Factory provider — tạo provider từ một factory function
    // Factory có thể async, có thể nhận dependency khác
    {
      provide: "DATABASE_CONNECTION",
      useFactory: async (configService: ConfigService) => {
        return createConnection({
          type: "postgres",
          host: configService.get("DB_HOST"),
          port: configService.get<number>("DB_PORT"),
        });
      },
      inject: [ConfigService], // inject dependency vào factory
    },

    // 4. Alias provider — tạo alias cho provider đã có
    { provide: "IUserService", useExisting: UserService },
    // Bây giờ inject 'IUserService' và UserService đều trả về cùng instance
  ],
})
export class UserModule {}

// Inject value/string token
@Injectable()
export class AuthService {
  constructor(
    @Inject("JWT_SECRET") private readonly jwtSecret: string,
    @Inject("APP_CONFIG") private readonly config: AppConfig,
  ) {}
}

// @Injectable() — đánh dấu class có thể được inject
@Injectable()
export class UserService {
  // constructor parameters được resolve tự động nhờ TypeScript type metadata
  constructor(
    private readonly userRepo: UserRepository, // inject bằng class type
    private readonly emailSvc: EmailService, // inject bằng class type

    // @Inject() cần thiết khi token là string
    @Inject("JWT_SECRET") private readonly secret: string,

    // @Inject() cần thiết khi inject interface (abstract class thường dùng thay)
    @Inject("INotificationService")
    private readonly notifier: INotificationService,
  ) {}
}

// Trường hợp hay gặp: @Inject() với token từ TypeORM
@Injectable()
export class UserRepository {
  constructor(
    @InjectRepository(User) // @InjectRepository = @Inject(getRepositoryToken(User))
    private readonly repo: Repository<User>,
  ) {}
}

// Ví dụ đầy đủ về DI flow

// 1. Define dependency (leaf node — không depend on gì thêm)
@Injectable()
export class MailService {
  async sendEmail(to: string, subject: string, body: string) {
    // gửi email thật
  }
}

// 2. Depend on MailService
@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User) private userRepo: Repository<User>,
    private mailService: MailService, // DI inject MailService vào đây
  ) {}

  async register(dto: CreateUserDto) {
    const user = await this.userRepo.save(dto);
    await this.mailService.sendEmail(user.email, "Welcome!", "...");
    return user;
  }
}

// 3. Controller depend on UserService
@Controller("users")
export class UserController {
  constructor(private userService: UserService) {} // DI inject UserService
}

// 4. Module khai báo để container biết
@Module({
  imports: [TypeOrmModule.forFeature([User])],
  providers: [UserService, MailService],
  controllers: [UserController],
})
export class UserModule {}

// Viết một dynamic module từ đầu — ví dụ: CacheModule
@Module({})
export class CacheModule {
  // forRoot — cấu hình toàn cục một lần ở AppModule
  static forRoot(options: CacheOptions): DynamicModule {
    return {
      module: CacheModule,
      global: true, // available khắp app mà không cần import lại
      providers: [
        {
          provide: "CACHE_OPTIONS",
          useValue: options,
        },
        CacheService,
      ],
      exports: [CacheService],
    };
  }

  // forRootAsync — khi options cần load async (ví dụ từ ConfigService)
  static forRootAsync(options: CacheAsyncOptions): DynamicModule {
    return {
      module: CacheModule,
      global: true,
      imports: options.imports || [],
      providers: [
        {
          provide: "CACHE_OPTIONS",
          useFactory: options.useFactory,
          inject: options.inject || [],
        },
        CacheService,
      ],
      exports: [CacheService],
    };
  }
}

// Sử dụng trong AppModule
@Module({
  imports: [
    CacheModule.forRoot({ ttl: 300, store: "redis" }),
    // Hoặc async:
    CacheModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: (config: ConfigService) => ({
        ttl: config.get<number>("CACHE_TTL"),
        store: config.get("CACHE_STORE"),
      }),
      inject: [ConfigService],
    }),
  ],
})
export class AppModule {}

// Cách 1: Functional middleware — đơn giản, không cần inject dependency
export function requestLogger(req: Request, res: Response, next: NextFunction) {
  const start = Date.now();
  res.on("finish", () => {
    const duration = Date.now() - start;
    console.log(`${req.method} ${req.url} ${res.statusCode} - ${duration}ms`);
  });
  next();
}

// Cách 2: Class middleware — có thể inject dependency qua DI
@Injectable()
export class AuthMiddleware implements NestMiddleware {
  constructor(private readonly jwtService: JwtService) {}

  use(req: Request, res: Response, next: NextFunction) {
    const token = req.headers.authorization?.split(" ")[1];
    if (token) {
      try {
        req["user"] = this.jwtService.verify(token);
      } catch {
        // token invalid — không throw, chỉ để req.user undefined
        // Guard sẽ quyết định có cho qua không
      }
    }
    next(); // luôn gọi next() trong middleware, trừ khi muốn chặn request
  }
}

@Module({
  controllers: [UserController, AuthController, ProductController],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(requestLogger) // functional middleware
      .forRoutes("*"); // tất cả routes

    consumer
      .apply(AuthMiddleware) // class middleware
      .exclude(
        { path: "auth/login", method: RequestMethod.POST },
        { path: "auth/register", method: RequestMethod.POST },
        { path: "health", method: RequestMethod.GET },
      )
      .forRoutes({ path: "*", method: RequestMethod.ALL }); // tất cả trừ những route trên

    // Áp dụng cho controller cụ thể (NestJS tự resolve routes)
    consumer
      .apply(RateLimitMiddleware)
      .forRoutes(UserController, ProductController);
  }
}

// 1. Định nghĩa custom exception
export class BusinessException extends HttpException {
  constructor(
    public readonly code: string,
    message: string,
    statusCode: number = HttpStatus.BAD_REQUEST,
  ) {
    super({ code, message, statusCode }, statusCode);
  }
}

// 2. Viết exception filter
@Catch(HttpException) // catch chỉ HttpException và subclasses
export class HttpExceptionFilter implements ExceptionFilter {
  constructor(private readonly logger: Logger) {}

  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();
    const status = exception.getStatus();
    const exceptionResponse = exception.getResponse();

    const errorBody = {
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      method: request.method,
      message:
        typeof exceptionResponse === "object"
          ? (exceptionResponse as any).message
          : exceptionResponse,
    };

    this.logger.error(
      `${request.method} ${request.url} → ${status}`,
      exception.stack,
    );

    response.status(status).json(errorBody);
  }
}

// 3. Catch tất cả exception (global fallback)
@Catch() // không có argument = catch tất cả
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();

    const status =
      exception instanceof HttpException
        ? exception.getStatus()
        : HttpStatus.INTERNAL_SERVER_ERROR;

    const message =
      exception instanceof HttpException
        ? exception.message
        : "Internal server error";

    // Log full error cho monitoring (Sentry, Datadog)
    if (!(exception instanceof HttpException)) {
      console.error("Unhandled exception:", exception);
      // Sentry.captureException(exception);
    }

    response.status(status).json({ statusCode: status, message });
  }
}

// Method level — chỉ áp dụng cho method này
@Post()
@UseFilters(HttpExceptionFilter)
async create(@Body() dto: CreateUserDto) {
  return this.userService.create(dto);
}

// Controller level — áp dụng cho tất cả method trong controller
@UseFilters(HttpExceptionFilter)
@Controller('users')
export class UserController { ... }

// Global level — áp dụng cho toàn bộ app
// Cách 1: trong main.ts (không có DI)
app.useGlobalFilters(new HttpExceptionFilter());

// Cách 2: qua module (có DI — inject được Logger, Config, v.v.)
@Module({
  providers: [
    { provide: APP_FILTER, useClass: AllExceptionsFilter },
    { provide: APP_FILTER, useClass: HttpExceptionFilter },
    // Có thể đăng ký nhiều filter — thực thi theo thứ tự ngược lại
  ],
})
export class AppModule {}

// 1. Built-in pipes phổ biến nhất

// ValidationPipe — validate DTO dựa trên class-validator decorators
// Nên luôn bật global với các option này
app.useGlobalPipes(new ValidationPipe({
  whitelist: true,        // tự động strip properties không có trong DTO
  forbidNonWhitelisted: true, // throw error nếu có extra properties
  transform: true,        // tự động transform (string → number, v.v.)
  transformOptions: { enableImplicitConversion: true },
}));

// ParseIntPipe — đảm bảo param là integer hợp lệ
@Get(':id')
findOne(@Param('id', ParseIntPipe) id: number) {
  // id đã là number, không phải string
  return this.service.findOne(id);
}

// ParseUUIDPipe — validate UUID format
@Get(':id')
findOne(@Param('id', ParseUUIDPipe) id: string) {
  // throw 400 nếu id không phải UUID hợp lệ
}

// DefaultValuePipe — cung cấp default value
@Get()
findAll(
  @Query('page', new DefaultValuePipe(1), ParseIntPipe) page: number,
  @Query('limit', new DefaultValuePipe(10), ParseIntPipe) limit: number,
) { ... }

// 2. Custom pipe — validation phức tạp hơn
@Injectable()
export class PositiveIntPipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata): number {
    const val = parseInt(value, 10);
    if (isNaN(val) || val <= 0) {
      throw new BadRequestException(
        `${metadata.data} must be a positive integer, received: ${value}`
      );
    }
    return val;
  }
}

// 3. Dùng class-validator trong DTO
export class CreateUserDto {
  @IsEmail()
  @IsNotEmpty()
  email: string;

  @IsString()
  @MinLength(8)
  @Matches(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)/, {
    message: 'Password must contain uppercase, lowercase and number',
  })
  password: string;

  @IsOptional()
  @IsEnum(UserRole)
  role?: UserRole;
}

// Middleware: không thể đọc metadata của handler
export class AuthMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    // ❌ Không biết handler sắp được gọi là gì
    // ❌ Không đọc được @Roles() metadata
    // ❌ Không biết handler có @Public() decorator không
    const token = extractToken(req);
    if (token) req['user'] = verify(token);
    next();
  }
}

// Guard: có đầy đủ context về handler
@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    // ✅ Đọc @Roles() metadata từ handler
    const requiredRoles = this.reflector.getAllAndOverride<string[]>('roles', [
      context.getHandler(), // method level metadata
      context.getClass(),   // class level metadata
    ]);

    // ✅ Nếu không có @Roles, cho qua (public endpoint)
    if (!requiredRoles) return true;

    // ✅ Kiểm tra user có role phù hợp không
    const { user } = context.switchToHttp().getRequest();
    return requiredRoles.some(role => user?.roles?.includes(role));
  }
}

// Guard còn có thể switch context: HTTP, WebSocket, RPC
// Middleware chỉ làm được với HTTP
canActivate(context: ExecutionContext) {
  if (context.getType() === 'http') { /* HTTP logic */ }
  if (context.getType() === 'ws') { /* WebSocket logic */ }
  if (context.getType<GqlContextType>() === 'graphql') { /* GraphQL logic */ }
}

// ❌ Sai khi guard có dependency
@UseGuards(new RolesGuard()) // Reflector sẽ là undefined!
@Controller('admin')
export class AdminController {}

// ✅ Đúng — NestJS inject Reflector tự động
@UseGuards(RolesGuard)
@Controller('admin')
export class AdminController {}

// ✅ Cũng đúng — khi nào KHÔNG có dependency thì new cũng OK
@UseGuards(new ThrottlerGuard()) // nếu ThrottlerGuard không cần inject gì

// Hoặc khi muốn pass config trực tiếp vào constructor
export class MaxFileSizeGuard implements CanActivate {
  constructor(private readonly maxSize: number) {} // primitive, không phải DI dependency
}
@UseGuards(new MaxFileSizeGuard(5 * 1024 * 1024)) // 5MB — hoàn toàn hợp lý

// Tạo @Roles decorator
export const ROLES_KEY = "roles";
export const Roles = (...roles: UserRole[]) => SetMetadata(ROLES_KEY, roles);

// Tạo @Public decorator — bypass auth hoàn toàn
export const IS_PUBLIC_KEY = "isPublic";
export const Public = () => SetMetadata(IS_PUBLIC_KEY, true);

// RolesGuard đọc metadata
@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
      context.getHandler(),
      context.getClass(),
    ]);
    if (isPublic) return true;

    const requiredRoles = this.reflector.getAllAndOverride<UserRole[]>(
      ROLES_KEY,
      [context.getHandler(), context.getClass()],
    );
    if (!requiredRoles?.length) return true;

    const { user } = context.switchToHttp().getRequest();
    if (!user) return false;
    return requiredRoles.some((role) => user.roles.includes(role));
  }
}

@Get('sensitive-data')
@UseGuards(JwtAuthGuard, RolesGuard)
@Roles(UserRole.ADMIN)
getSensitiveData() { ... }

@UseGuards(JwtAuthGuard)
@Controller('admin')
export class AdminController {
  @Get('users') // JwtAuthGuard tự động áp dụng
  getUsers() { ... }

  @Get('stats') // JwtAuthGuard tự động áp dụng
  getStats() { ... }
}

app.useGlobalGuards(new JwtAuthGuard());

@Module({
  providers: [{ provide: APP_GUARD, useClass: JwtAuthGuard }],
})
export class AppModule {}

// 1. Logging interceptor — đo thời gian thực thi
@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const req = context.switchToHttp().getRequest();
    const now = Date.now();
    console.log(`→ ${req.method} ${req.url}`);

    return next
      .handle()
      .pipe(
        tap(() =>
          console.log(`← ${req.method} ${req.url} ${Date.now() - now}ms`),
        ),
      );
  }
}

// 2. Transform response — wrap tất cả response trong cùng format
@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<
  T,
  ApiResponse<T>
> {
  intercept(
    context: ExecutionContext,
    next: CallHandler,
  ): Observable<ApiResponse<T>> {
    return next.handle().pipe(
      map((data) => ({
        success: true,
        data,
        timestamp: new Date().toISOString(),
      })),
    );
  }
}
// Mọi endpoint tự động return: { success: true, data: {...}, timestamp: "..." }

// 3. Cache interceptor
@Injectable()
export class CacheInterceptor implements NestInterceptor {
  constructor(private cacheService: CacheService) {}

  async intercept(
    context: ExecutionContext,
    next: CallHandler,
  ): Promise<Observable<any>> {
    const req = context.switchToHttp().getRequest();
    const cacheKey = `${req.method}:${req.url}`;

    const cached = await this.cacheService.get(cacheKey);
    if (cached) return of(cached); // return cached, không gọi handler

    return next.handle().pipe(
      tap((data) => this.cacheService.set(cacheKey, data, 300)), // cache 5 phút
    );
  }
}

// 4. Exception mapping interceptor
@Injectable()
export class ErrorsInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      catchError((err) => {
        if (err instanceof QueryFailedError) {
          // Map TypeORM error sang NestJS HTTP exception
          if (err.message.includes("duplicate key")) {
            return throwError(
              () => new ConflictException("Resource already exists"),
            );
          }
        }
        return throwError(() => err);
      }),
    );
  }
}

import { Injectable, Scope, Inject } from '@nestjs/common';
import { REQUEST } from '@nestjs/core';

// Singleton (mặc định) — không cần khai báo
@Injectable()
export class DatabaseService { ... }

// Request-scoped — mỗi request một instance
@Injectable({ scope: Scope.REQUEST })
export class RequestContextService {
  private requestId: string;

  constructor(@Inject(REQUEST) private readonly request: Request) {
    // Inject request object trực tiếp
    this.requestId = request.headers['x-request-id'] || generateId();
  }

  getRequestId(): string { return this.requestId; }
  getCurrentUser(): User { return this.request['user']; }
}

// Transient — mỗi lần inject một instance
@Injectable({ scope: Scope.TRANSIENT })
export class UniqueIdService {
  private readonly id = Math.random().toString(36).substr(2, 9);
  getId() { return this.id; }
}

// Cả 4 tính chất trong một ví dụ thực tế NestJS

// Abstraction: interface định nghĩa contract
interface PaymentProvider {
  charge(amount: number, currency: string): Promise<PaymentResult>;
  refund(transactionId: string): Promise<void>;
}

// Encapsulation: StripeProvider quản lý state nội bộ, ẩn Stripe SDK
class StripeProvider implements PaymentProvider {
  private stripeClient: Stripe; // ẩn implementation detail

  constructor(private readonly apiKey: string) {
    this.stripeClient = new Stripe(apiKey); // logic khởi tạo bên trong
  }

  async charge(amount: number, currency: string): Promise<PaymentResult> {
    // caller không cần biết Stripe SDK được dùng thế nào
    const intent = await this.stripeClient.paymentIntents.create({
      amount: amount * 100, // Stripe dùng cents
      currency,
    });
    return { transactionId: intent.id, status: intent.status };
  }

  async refund(transactionId: string): Promise<void> {
    await this.stripeClient.refunds.create({ payment_intent: transactionId });
  }
}

// Inheritance: MomoProvider kế thừa base logic nhưng override specifics
abstract class BasePaymentProvider implements PaymentProvider {
  protected async validateAmount(amount: number): Promise<void> {
    if (amount <= 0) throw new Error("Amount must be positive");
    if (amount > 100_000_000) throw new Error("Amount exceeds limit");
  }
  abstract charge(amount: number, currency: string): Promise<PaymentResult>;
  abstract refund(transactionId: string): Promise<void>;
}

class MomoProvider extends BasePaymentProvider {
  async charge(amount: number, currency: string) {
    await this.validateAmount(amount); // dùng logic từ parent
    // ... Momo specific logic
  }
  async refund(transactionId: string) {
    /* Momo refund */
  }
}

// Polymorphism: PaymentService không biết provider cụ thể nào
@Injectable()
class PaymentService {
  constructor(@Inject("PAYMENT_PROVIDER") private provider: PaymentProvider) {}

  async processPayment(order: Order) {
    return this.provider.charge(order.total, order.currency);
    // Dù inject Stripe hay Momo, code này không đổi
  }
}

// TypeORM — schema trong TypeScript class
@Entity("users")
export class User {
  @PrimaryGeneratedColumn("uuid")
  id: string;

  @Column({ unique: true })
  email: string;

  @OneToMany(() => Order, (order) => order.user, { lazy: true })
  orders: Promise<Order[]>; // lazy loading với Promise

  @CreateDateColumn()
  createdAt: Date;
}

// TypeORM Query — QueryBuilder rất linh hoạt
const result = await this.userRepo
  .createQueryBuilder("u")
  .select(["u.id", "u.email", "COUNT(o.id) as orderCount"])
  .leftJoin("u.orders", "o", "o.status = :status", { status: "completed" })
  .where("u.createdAt > :date", { date: startDate })
  .groupBy("u.id")
  .having("COUNT(o.id) > :min", { min: 5 })
  .orderBy("orderCount", "DESC")
  .getRawMany();

// Prisma — schema trong .prisma file, client được generate
// schema.prisma:
// model User {
//   id        String   @id @default(uuid())
//   email     String   @unique
//   orders    Order[]
//   createdAt DateTime @default(now())
// }

// Prisma Query — type-safe, autocomplete đầy đủ
const users = await prisma.user.findMany({
  where: {
    createdAt: { gt: startDate },
    orders: { some: { status: "completed" } },
  },
  include: {
    orders: {
      where: { status: "completed" },
      select: { id: true, amount: true },
    },
  },
  orderBy: { createdAt: "desc" },
});
// users có type đầy đủ, autocomplete cho orders.amount

// ---- CALLBACK ----
import fs from 'fs';

// Error-first callback convention
fs.readFile('config.json', 'utf8', (err, data) => {
  if (err) {
    console.error('Read error:', err);
    return;
  }
  JSON.parse(data); // nếu parse fail, error không được catch!
});

// Callback hell — 3 operations tuần tự
db.query('SELECT id FROM users WHERE email = ?', [email], (err, user) => {
  if (err) return handleError(err);
  db.query('SELECT * FROM orders WHERE user_id = ?', [user.id], (err, orders) => {
    if (err) return handleError(err);
    db.query('INSERT INTO audit_log ...', [...], (err, result) => {
      if (err) return handleError(err);
      // 3 levels deep, và còn nhiều hơn nữa
    });
  });
});

// ---- PROMISE ----
function readFilePromise(path: string): Promise<string> {
  return new Promise((resolve, reject) => {
    fs.readFile(path, 'utf8', (err, data) => {
      if (err) reject(err);
      else resolve(data);
    });
  });
}

// Chaining — phẳng hơn callback hell
readFilePromise('config.json')
  .then(data => JSON.parse(data))
  .then(config => fetchUser(config.userId))
  .then(user => sendEmail(user.email))
  .catch(err => console.error('Somewhere failed:', err)) // catch mọi lỗi trong chain
  .finally(() => cleanup());

// Promise.all — chạy song song, chờ tất cả
const [users, products, orders] = await Promise.all([
  fetchUsers(),
  fetchProducts(),
  fetchOrders(),
]); // nhanh hơn chạy tuần tự 3 lần

// Promise.allSettled — chờ tất cả dù có cái fail
const results = await Promise.allSettled([fetchA(), fetchB(), fetchC()]);
results.forEach(result => {
  if (result.status === 'fulfilled') console.log(result.value);
  else console.error(result.reason);
});

// Promise.race — lấy cái nào xong trước (dùng cho timeout)
const result = await Promise.race([
  fetchData(),
  new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), 5000))
]);

// ---- ASYNC/AWAIT ----
async function processOrder(orderId: string): Promise<OrderResult> {
  try {
    const order = await fetchOrder(orderId); // không block event loop
    const user = await fetchUser(order.userId);
    const payment = await processPayment(order.amount);
    await sendConfirmation(user.email);
    return { order, payment };
  } catch (err) {
    if (err instanceof PaymentError) {
      await refundPartial(orderId);
      throw new BadRequestException('Payment failed, partial refund initiated');
    }
    throw err; // re-throw nếu không biết handle
  } finally {
    await releaseOrderLock(orderId); // luôn chạy dù success hay fail
  }
}

// Lỗi thường gặp: await trong loop (tuần tự thay vì song song)
// ❌ Chậm: mỗi iteration chờ cái trước
for (const id of userIds) {
  const user = await fetchUser(id); // N requests tuần tự
}

// ✅ Nhanh hơn: tất cả requests song song
const users = await Promise.all(userIds.map(id => fetchUser(id)));

console.log("1"); // synchronous

setTimeout(() => console.log("2"), 0); // macrotask — đi vào timer queue

Promise.resolve().then(() => console.log("3")); // microtask

queueMicrotask(() => console.log("4")); // microtask

console.log("5"); // synchronous

// Output: 1, 5, 3, 4, 2
// Giải thích:
// - 1, 5: synchronous, chạy ngay trên call stack
// - Sau khi call stack rỗng, event loop kiểm tra microtask queue
// - 3, 4: microtasks (Promise và queueMicrotask), ưu tiên hơn macrotask
// - 2: macrotask (setTimeout) chạy sau khi microtask queue rỗng

// Ví dụ transaction với TypeORM — đảm bảo ACID cho transfer tiền
@Injectable()
export class TransactionService {
  constructor(private readonly dataSource: DataSource) {}

  async transferFunds(fromId: string, toId: string, amount: number) {
    const queryRunner = this.dataSource.createQueryRunner();
    await queryRunner.connect();
    await queryRunner.startTransaction("REPEATABLE READ"); // isolation level

    try {
      // Atomicity: nếu bất kỳ bước nào fail, toàn bộ rollback
      const sender = await queryRunner.manager.findOne(Account, {
        where: { id: fromId },
        lock: { mode: "pessimistic_write" }, // prevent race condition
      });

      if (!sender || sender.balance < amount) {
        throw new BadRequestException("Insufficient funds");
      }

      // Consistency: database constraint CHECK (balance >= 0) sẽ bắt lỗi nếu âm
      await queryRunner.manager.decrement(
        Account,
        { id: fromId },
        "balance",
        amount,
      );
      await queryRunner.manager.increment(
        Account,
        { id: toId },
        "balance",
        amount,
      );

      // Ghi audit log trong cùng transaction — atomicity đảm bảo đồng bộ
      await queryRunner.manager.save(AuditLog, {
        type: "TRANSFER",
        fromId,
        toId,
        amount,
        timestamp: new Date(),
      });

      await queryRunner.commitTransaction(); // Durability: WAL ghi xuống disk
    } catch (error) {
      await queryRunner.rollbackTransaction(); // Atomicity: hoàn tác tất cả
      throw error;
    } finally {
      await queryRunner.release();
    }
  }
}

// Vấn đề: User A connect Server 1, User B connect Server 2
// Server 1 emit event → User B (ở Server 2) không nhận được

// Giải pháp: Redis Pub/Sub Adapter
// Khi Server 1 emit → publish lên Redis channel
// Server 2 subscribe Redis channel → nhận → forward tới clients của mình

// NestJS config
const pubClient = new Redis(redisConfig);
const subClient = pubClient.duplicate();
io.adapter(createAdapter(pubClient, subClient));

// Event-driven (fire and forget)
this.rmqClient.emit("task.created", { taskId, projectId, assigneeId });

// Request-response (cần kết quả)
const user = await firstValueFrom(
  this.rmqClient.send({ cmd: "get_user" }, { userId }).pipe(timeout(5000)),
);

// Ví dụ điển hình: lấy 10 posts với tên author của mỗi post

// ❌ N+1: 1 query lấy posts + 10 queries lấy author
const posts = await postRepo.find({ take: 10 }); // Query 1: SELECT * FROM posts LIMIT 10
for (const post of posts) {
  const author = await post.author; // Query 2-11: SELECT * FROM users WHERE id = ?
  console.log(author.name);
}
// Tổng: 11 queries

// Phát hiện: enable TypeORM logging
TypeOrmModule.forRoot({
  logging: ["query"], // log tất cả queries ra console
});
// Hoặc dùng pg_stat_statements trong PostgreSQL để track query patterns

// ✅ Fix 1: Eager loading với relations
const posts = await postRepo.find({
  take: 10,
  relations: ["author", "author.profile"], // JOIN trong 1 query
});

// ✅ Fix 2: QueryBuilder với explicit JOIN
const posts = await postRepo
  .createQueryBuilder("post")
  .leftJoinAndSelect("post.author", "author")
  .leftJoinAndSelect("post.tags", "tag")
  .take(10)
  .getMany();

// ✅ Fix 3 với Prisma — include luôn JOIN
const posts = await prisma.post.findMany({
  take: 10,
  include: {
    author: { select: { id: true, name: true, avatar: true } },
    tags: true,
    _count: { select: { comments: true } }, // count comments, không fetch all
  },
});

// ✅ Fix 4: DataLoader pattern (quan trọng với GraphQL)
// Batch nhiều individual requests thành 1 query
class UserDataLoader extends DataLoader<string, User> {
  constructor(private userRepo: UserRepository) {
    super(async (userIds: readonly string[]) => {
      const users = await userRepo.findByIds([...userIds]);
      // Map về đúng thứ tự của keys
      return userIds.map((id) => users.find((u) => u.id === id) ?? null);
    });
  }
}
// Thay vì 10 queries riêng, loader batch thành:
// SELECT * FROM users WHERE id IN ('id1', 'id2', ..., 'id10')

# Multi-stage build — production image tối ưu
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci                    # install tất cả (kể cả devDependencies)
COPY . .
RUN npm run build             # compile TypeScript → dist/

FROM node:20-alpine AS production
WORKDIR /app
# Chỉ copy những gì production cần
COPY package*.json ./
RUN npm ci --omit=dev         # chỉ production dependencies
COPY --from=builder /app/dist ./dist

# Security: không chạy với root user
RUN addgroup -g 1001 -S nodejs && adduser -S nestjs -u 1001
USER nestjs

EXPOSE 3000
HEALTHCHECK --interval=30s --timeout=10s \
  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1

CMD ["node", "dist/main.js"]

# docker-compose.yml cho local development
services:
  api:
    build:
      context: .
      target: builder # dùng builder stage (có devDeps, hot reload)
    volumes:
      - ./src:/app/src # mount source code → hot reload
      - ./test:/app/test
    command: npm run start:dev
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgres://postgres:secret@postgres:5432/devdb
      REDIS_URL: redis://redis:6379
      RABBITMQ_URL: amqp://admin:secret@rabbitmq:5672
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - app-network

  postgres:
    image: postgres:16-alpine
    volumes:
      - postgres_data:/var/lib/postgresql/data # persist data
    environment:
      POSTGRES_DB: devdb
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: secret
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
    networks:
      - app-network

  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes # persistence
    volumes:
      - redis_data:/data
    networks:
      - app-network

  rabbitmq:
    image: rabbitmq:3-management-alpine
    ports:
      - "15672:15672" # management UI
    environment:
      RABBITMQ_DEFAULT_USER: admin
      RABBITMQ_DEFAULT_PASS: secret
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq
    networks:
      - app-network

volumes:
  postgres_data:
  redis_data:
  rabbitmq_data:

networks:
  app-network:
    driver: bridge

-- PostgreSQL: tìm query chậm nhất trong 24h qua
SELECT query, calls, mean_exec_time, total_exec_time,
       rows, shared_blks_hit, shared_blks_read
FROM pg_stat_statements
WHERE mean_exec_time > 100    -- query > 100ms
ORDER BY mean_exec_time DESC
LIMIT 20;

-- Hoặc enable slow query log
-- postgresql.conf:
-- log_min_duration_statement = 100    # log query > 100ms
-- log_statement = 'all'               # hoặc log tất cả

-- EXPLAIN: chỉ show execution plan (không thực sự chạy)
-- EXPLAIN ANALYZE: chạy thật và show actual time + rows
EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)
SELECT o.*, u.name, u.email
FROM orders o
JOIN users u ON u.id = o.user_id
WHERE o.status = 'pending'
  AND o.created_at > NOW() - INTERVAL '7 days'
ORDER BY o.created_at DESC;

-- Đọc output: tìm các dấu hiệu xấu:
-- "Seq Scan" trên bảng lớn → cần index
-- "rows=1000000" nhưng "actual rows=10" → estimate sai → cần ANALYZE
-- "Hash Join" với nhiều rows → có thể optimize thành "Nested Loop" với index đúng
-- "Sort" tốn nhiều memory → cần index có ORDER BY phù hợp

-- Index thường dùng
CREATE INDEX idx_orders_status_created
ON orders(status, created_at DESC)    -- composite, match WHERE + ORDER BY
WHERE status = 'pending';             -- partial index — chỉ index pending orders

-- Covering index — index chứa luôn data cần SELECT, tránh heap fetch
CREATE INDEX idx_orders_covering
ON orders(user_id, created_at DESC)
INCLUDE (id, status, total_amount);  -- INCLUDE columns không dùng để filter

-- Index cho JSONB
CREATE INDEX idx_products_metadata_category
ON products USING gin((metadata -> 'category'));  -- GIN cho JSONB containment

-- Check index có được dùng không
SELECT schemaname, tablename, indexname, idx_scan, idx_tup_read
FROM pg_stat_user_indexes
WHERE tablename = 'orders'
ORDER BY idx_scan DESC;
-- idx_scan = 0 → index không được dùng → có thể drop

-- Tránh function trong WHERE clause (ngăn index usage)
-- ❌ Không dùng index trên created_at
WHERE DATE(created_at) = '2024-01-01'

-- ✅ Dùng range comparison
WHERE created_at >= '2024-01-01' AND created_at < '2024-01-02'

-- Tránh SELECT * — fetch chỉ những column cần
-- ❌
SELECT * FROM users WHERE id = $1;
-- ✅
SELECT id, name, email FROM users WHERE id = $1;

-- Pagination: dùng cursor thay vì OFFSET lớn
-- ❌ Chậm khi offset lớn (phải skip 100000 rows)
SELECT * FROM posts ORDER BY created_at DESC LIMIT 20 OFFSET 100000;

-- ✅ Cursor-based pagination
SELECT * FROM posts
WHERE created_at < :lastSeenCursor
ORDER BY created_at DESC
LIMIT 20;

@Injectable()
export class ProductService {
  constructor(
    private readonly redis: Redis,
    private readonly productRepo: ProductRepository,
  ) {}

  async findAll(filters: ProductFilters): Promise<Product[]> {
    const cacheKey = `products:${JSON.stringify(filters)}`;
    const cached = await this.redis.get(cacheKey);
    if (cached) return JSON.parse(cached);

    const products = await this.productRepo.find(filters);
    await this.redis.setex(cacheKey, 300, JSON.stringify(products)); // 5 phút
    return products;
  }

  async update(id: string, dto: UpdateProductDto): Promise<Product> {
    const product = await this.productRepo.update(id, dto);
    // Invalidate cache khi data thay đổi
    const keys = await this.redis.keys("products:*");
    if (keys.length) await this.redis.del(keys);
    return product;
  }
}

-- VACUUM ANALYZE: cập nhật statistics và reclaim dead tuples
VACUUM ANALYZE orders;

-- Autovacuum tuning (cho bảng write-heavy)
ALTER TABLE orders SET (
  autovacuum_vacuum_scale_factor = 0.01,  -- vacuum khi 1% rows là dead
  autovacuum_analyze_scale_factor = 0.005
);

-- Table partitioning cho bảng rất lớn (hàng tỷ rows)
CREATE TABLE orders (
  id UUID,
  created_at TIMESTAMPTZ,
  ...
) PARTITION BY RANGE (created_at);

CREATE TABLE orders_2024_q1 PARTITION OF orders
FOR VALUES FROM ('2024-01-01') TO ('2024-04-01');
-- Query với WHERE created_at IN 2024_q1 chỉ scan partition đó

// ---- Cài đặt CQRS trong NestJS ----
// npm install @nestjs/cqrs

// 1. COMMAND — biểu diễn ý định thay đổi state
// Command chỉ là plain object chứa data cần thiết
export class CreateTaskCommand {
  constructor(
    public readonly projectId: string,
    public readonly title: string,
    public readonly assigneeId: string,
    public readonly createdBy: string,
  ) {}
}

// 2. COMMAND HANDLER — thực thi command, chứa business logic
@CommandHandler(CreateTaskCommand)
export class CreateTaskHandler implements ICommandHandler<CreateTaskCommand> {
  constructor(
    @InjectRepository(Task)
    private readonly taskRepo: Repository<Task>,
    private readonly eventBus: EventBus, // publish domain events
    private readonly projectService: ProjectService,
  ) {}

  async execute(command: CreateTaskCommand): Promise<Task> {
    // Business logic: validate
    const project = await this.projectService.findById(command.projectId);
    if (!project.isActive()) {
      throw new BadRequestException("Cannot create task in inactive project");
    }

    // Create aggregate
    const task = Task.create({
      projectId: command.projectId,
      title: command.title,
      assigneeId: command.assigneeId,
      createdBy: command.createdBy,
      status: TaskStatus.TODO,
    });

    const saved = await this.taskRepo.save(task);

    // Publish domain event — decoupled notification
    this.eventBus.publish(new TaskCreatedEvent(saved.id, command.assigneeId));

    return saved;
  }
}

// 3. QUERY — biểu diễn yêu cầu đọc data
export class GetProjectTasksQuery {
  constructor(
    public readonly projectId: string,
    public readonly filters: TaskFilters,
    public readonly pagination: PaginationDto,
  ) {}
}

// 4. QUERY HANDLER — tối ưu cho read, có thể dùng raw SQL hay denormalized view
@QueryHandler(GetProjectTasksQuery)
export class GetProjectTasksHandler implements IQueryHandler<
  GetProjectTasksQuery,
  PaginatedResult<TaskDto>
> {
  constructor(private readonly dataSource: DataSource) {}

  async execute(
    query: GetProjectTasksQuery,
  ): Promise<PaginatedResult<TaskDto>> {
    // Query handler có thể bypass ORM để dùng raw SQL tối ưu hơn
    const result = await this.dataSource.query(
      `
      SELECT
        t.id, t.title, t.status, t.priority, t.due_date,
        u.name AS assignee_name, u.avatar AS assignee_avatar,
        COUNT(c.id) AS comment_count
      FROM tasks t
      LEFT JOIN users u ON u.id = t.assignee_id
      LEFT JOIN comments c ON c.task_id = t.id
      WHERE t.project_id = $1
        AND ($2::text IS NULL OR t.status = $2)
      GROUP BY t.id, u.name, u.avatar
      ORDER BY t.created_at DESC
      LIMIT $3 OFFSET $4
    `,
      [
        query.projectId,
        query.filters.status,
        query.pagination.limit,
        query.pagination.offset,
      ],
    );

    return { data: result, total: result.length };
  }
}

// 5. DOMAIN EVENT — side effects được xử lý tách biệt
export class TaskCreatedEvent {
  constructor(
    public readonly taskId: string,
    public readonly assigneeId: string,
  ) {}
}

@EventsHandler(TaskCreatedEvent)
export class TaskCreatedHandler implements IEventHandler<TaskCreatedEvent> {
  constructor(
    private readonly notificationService: NotificationService,
    private readonly auditService: AuditService,
  ) {}

  async handle(event: TaskCreatedEvent) {
    // Side effects chạy async, không block command
    await Promise.all([
      this.notificationService.notifyAssignee(event.assigneeId, event.taskId),
      this.auditService.log("TASK_CREATED", event.taskId),
    ]);
  }
}

// 6. CONTROLLER sử dụng CommandBus và QueryBus
@Controller("tasks")
@UseGuards(JwtAuthGuard)
export class TaskController {
  constructor(
    private readonly commandBus: CommandBus,
    private readonly queryBus: QueryBus,
  ) {}

  @Post()
  @HttpCode(HttpStatus.CREATED)
  async create(@Body() dto: CreateTaskDto, @CurrentUser("id") userId: string) {
    return this.commandBus.execute(
      new CreateTaskCommand(dto.projectId, dto.title, dto.assigneeId, userId),
    );
  }

  @Get("project/:projectId")
  async findAll(
    @Param("projectId") projectId: string,
    @Query() filters: TaskFilters,
    @Query() pagination: PaginationDto,
  ) {
    return this.queryBus.execute(
      new GetProjectTasksQuery(projectId, filters, pagination),
    );
  }
}

// 7. Module setup
@Module({
  imports: [CqrsModule, TypeOrmModule.forFeature([Task])],
  controllers: [TaskController],
  providers: [CreateTaskHandler, GetProjectTasksHandler, TaskCreatedHandler],
})
export class TaskModule {}