Exemplos NestJS

// NestJS Hello World Examples

// 1. Basic NestJS Application Structure
// src/main.ts
import { NestFactory } from '@nestjs/core'
import { AppModule } from './app.module'
import { ValidationPipe } from '@nestjs/common'

async function bootstrap() {
  const app = await NestFactory.create(AppModule)

  // Enable validation globally
  app.useGlobalPipes(new ValidationPipe())

  // Enable CORS
  app.enableCors()

  // Prefix all routes
  app.setGlobalPrefix('api')

  await app.listen(3000)
  console.log('🚀 Application is running on: http://localhost:3000')
}

bootstrap()

// src/app.module.ts
import { Module } from '@nestjs/common'
import { AppController } from './app.controller'
import { AppService } from './app.service'

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

// src/app.controller.ts
import { Controller, Get, Param, Query, Post, Body } from '@nestjs/common'
import { AppService } from './app.service'
import { CreateHelloDto } from './dto/create-hello.dto'

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(): string {
    return this.appService.getHello()
  }

  @Get('hello/:name')
  getHelloName(@Param('name') name: string): string {
    return this.appService.getHelloName(name)
  }

  @Get('greet')
  greet(@Query('name') name: string): object {
    return this.appService.greet(name)
  }

  @Post('hello')
  createHello(@Body() createHelloDto: CreateHelloDto): object {
    return this.appService.createHello(createHelloDto)
  }
}

// src/app.service.ts
import { Injectable } from '@nestjs/common'

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

  getHelloName(name: string): string {
    return `Hello, ${name}!`
  }

  greet(name: string): object {
    return {
      message: `Hello, ${name || 'Guest'}!`,
      timestamp: new Date().toISOString(),
      framework: 'NestJS'
    }
  }

  createHello(data: { name: string; message: string }): object {
    return {
      id: Math.random(),
      ...data,
      createdAt: new Date().toISOString()
    }
  }
}

// src/dto/create-hello.dto.ts
import { IsString, IsOptional } from 'class-validator'

export class CreateHelloDto {
  @IsString()
  name: string

  @IsString()
  @IsOptional()
  message?: string
}

// 2. NestJS with Multiple Controllers
// src/users/users.controller.ts
import { Controller, Get, Post, Put, Delete, Param, Body, HttpStatus, HttpException } from '@nestjs/common'
import { UsersService } from './users.service'
import { CreateUserDto, UpdateUserDto } from './dto'

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  async create(@Body() createUserDto: CreateUserDto) {
    try {
      return await this.usersService.create(createUserDto)
    } catch (error) {
      throw new HttpException(error.message, HttpStatus.BAD_REQUEST)
    }
  }

  @Get()
  async findAll() {
    return this.usersService.findAll()
  }

  @Get(':id')
  async findOne(@Param('id') id: string) {
    const user = await this.usersService.findOne(+id)
    if (!user) {
      throw new HttpException('User not found', HttpStatus.NOT_FOUND)
    }
    return user
  }

  @Put(':id')
  async update(@Param('id') id: string, @Body() updateUserDto: UpdateUserDto) {
    const user = await this.usersService.update(+id, updateUserDto)
    if (!user) {
      throw new HttpException('User not found', HttpStatus.NOT_FOUND)
    }
    return user
  }

  @Delete(':id')
  async remove(@Param('id') id: string) {
    const result = await this.usersService.remove(+id)
    if (!result) {
      throw new HttpException('User not found', HttpStatus.NOT_FOUND)
    }
    return { message: 'User deleted successfully' }
  }
}

// src/users/users.service.ts
import { Injectable, NotFoundException } from '@nestjs/common'
import { CreateUserDto, UpdateUserDto } from './dto'

export interface User {
  id: number
  name: string
  email: string
  age?: number
  createdAt: Date
  updatedAt: Date
}

@Injectable()
export class UsersService {
  private users: User[] = []
  private nextId = 1

  create(createUserDto: CreateUserDto): User {
    const user: User = {
      id: this.nextId++,
      ...createUserDto,
      createdAt: new Date(),
      updatedAt: new Date()
    }
    this.users.push(user)
    return user
  }

  findAll(): User[] {
    return this.users
  }

  findOne(id: number): User | undefined {
    return this.users.find(user => user.id === id)
  }

  update(id: number, updateUserDto: UpdateUserDto): User | undefined {
    const userIndex = this.users.findIndex(user => user.id === id)
    if (userIndex === -1) {
      return undefined
    }

    this.users[userIndex] = {
      ...this.users[userIndex],
      ...updateUserDto,
      updatedAt: new Date()
    }

    return this.users[userIndex]
  }

  remove(id: number): boolean {
    const userIndex = this.users.findIndex(user => user.id === id)
    if (userIndex === -1) {
      return false
    }

    this.users.splice(userIndex, 1)
    return true
  }
}

// src/users/dto/index.ts
export class CreateUserDto {
  name: string
  email: string
  age?: number
}

export class UpdateUserDto {
  name?: string
  email?: string
  age?: number
}

// 3. NestJS with Modules and Dependencies
// src/users/users.module.ts
import { Module } from '@nestjs/common'
import { UsersController } from './users.controller'
import { UsersService } from './users.service'
import { DatabaseModule } from '../database/database.module'

@Module({
  imports: [DatabaseModule],
  controllers: [UsersController],
  providers: [UsersService],
  exports: [UsersService],
})
export class UsersModule {}

// src/database/database.module.ts
import { Module, Global } from '@nestjs/common'
import { DatabaseService } from './database.service'

@Global()
@Module({
  providers: [DatabaseService],
  exports: [DatabaseService],
})
export class DatabaseModule {}

// src/database/database.service.ts
import { Injectable } from '@nestjs/common'

export interface DatabaseConnection {
  connect(): Promise<void>
  disconnect(): Promise<void>
  query(sql: string, params?: any[]): Promise<any>
}

@Injectable()
export class DatabaseService {
  private connection: DatabaseConnection

  constructor() {
    this.connection = new PostgresConnection()
  }

  async connect() {
    await this.connection.connect()
  }

  async disconnect() {
    await this.connection.disconnect()
  }

  async query(sql: string, params?: any[]) {
    return this.connection.query(sql, params)
  }
}

class PostgresConnection implements DatabaseConnection {
  async connect() {
    console.log('Connecting to PostgreSQL...')
  }

  async disconnect() {
    console.log('Disconnecting from PostgreSQL...')
  }

  async query(sql: string, params?: any[]) {
    console.log(`Query: ${sql}`, params)
    return { rows: [] }
  }
}

// 4. NestJS with Custom Decorators
// src/decorators/user.decorator.ts
import { createParamDecorator, ExecutionContext } from '@nestjs/common'

export const User = createParamDecorator(
  (data: string, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest()
    const user = request.user

    return data ? user?.[data] : user
  },
)

// src/decorators/roles.decorator.ts
import { SetMetadata } from '@nestjs/common'

export const Roles = (...roles: string[]) => SetMetadata('roles', roles)

// Usage in controllers
// src/admin/admin.controller.ts
import { Controller, Get, UseGuards } from '@nestjs/common'
import { RolesGuard } from './guards/roles.guard'
import { Roles } from '../decorators/roles.decorator'
import { User } from '../decorators/user.decorator'

@Controller('admin')
@UseGuards(RolesGuard)
@Roles('admin')
export class AdminController {
  @Get('dashboard')
  getDashboard(@User('id') userId: number) {
    return {
      message: 'Admin dashboard',
      userId,
      data: 'Sensitive admin data'
    }
  }

  @Get('users')
  getUsers() {
    return {
      message: 'All users list',
      users: []
    }
  }
}

// 5. NestJS with Guards and Middleware
// src/guards/auth.guard.ts
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common'

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest()
    const token = request.headers.authorization?.replace('Bearer ', '')

    // Simple token validation
    if (!token || token !== 'valid-token') {
      return false
    }

    // Attach user to request
    request.user = {
      id: 1,
      name: 'John Doe',
      role: 'user'
    }

    return true
  }
}

// src/guards/roles.guard.ts
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common'
import { Reflector } from '@nestjs/core'

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const requiredRoles = this.reflector.get<string[]>('roles', context.getHandler())
    if (!requiredRoles) {
      return true
    }

    const { user } = context.switchToHttp().getRequest()
    return requiredRoles.some(role => user.role === role)
  }
}

// src/middleware/logging.middleware.ts
import { Injectable, NestMiddleware } from '@nestjs/common'
import { Request, Response, NextFunction } from 'express'

@Injectable()
export class LoggingMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    const start = Date.now()
    const { method, url, ip } = req

    console.log(`[${new Date().toISOString()}] ${method} ${url} - ${ip}`)

    res.on('finish', () => {
      const duration = Date.now() - start
      console.log(`[${new Date().toISOString()}] ${method} ${url} - ${res.statusCode} (${duration}ms)`)
    })

    next()
  }
}

// Apply middleware in app module
// src/app.module.ts
import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common'
import { LoggingMiddleware } from './middleware/logging.middleware'
import { UsersModule } from './users/users.module'
import { AuthModule } from './auth/auth.module'

@Module({
  imports: [UsersModule, AuthModule],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggingMiddleware)
      .forRoutes('*')
  }
}

// 6. NestJS with Interceptors and Filters
// src/interceptors/transform.interceptor.ts
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common'
import { Observable } from 'rxjs'
import { map } from 'rxjs/operators'

export interface Response<T> {
  data: T
  timestamp: string
  success: boolean
}

@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<T, Response<T>> {
  intercept(context: ExecutionContext, next: CallHandler): Observable<Response<T>> {
    return next.handle().pipe(
      map(data => ({
        data,
        timestamp: new Date().toISOString(),
        success: true
      }))
    )
  }
}

// src/interceptors/caching.interceptor.ts
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common'
import { Observable, of } from 'rxjs'
import { tap } from 'rxjs/operators'

@Injectable()
export class CachingInterceptor implements NestInterceptor {
  private cache = new Map<string, any>()

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const key = context.switchToHttp().getRequest().url

    if (this.cache.has(key)) {
      return of(this.cache.get(key))
    }

    return next.handle().pipe(
      tap(data => {
        this.cache.set(key, data)
      })
    )
  }
}

// src/filters/http-exception.filter.ts
import { ExceptionFilter, Catch, ArgumentsHost, HttpException, HttpStatus } from '@nestjs/common'
import { Request, Response } from 'express'

@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
  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()

    response
      .status(status)
      .json({
        statusCode: status,
        timestamp: new Date().toISOString(),
        path: request.url,
        method: request.method,
        message: typeof exceptionResponse === 'string'
          ? exceptionResponse
          : (exceptionResponse as any).message,
        error: exception.constructor.name
      })
  }
}

// Apply globally in main.ts
// src/main.ts
import { NestFactory } from '@nestjs/core'
import { AppModule } from './app.module'
import { ValidationPipe } from '@nestjs/common'
import { TransformInterceptor } from './interceptors/transform.interceptor'

async function bootstrap() {
  const app = await NestFactory.create(AppModule)

  app.useGlobalPipes(new ValidationPipe())
  app.useGlobalFilters(new HttpExceptionFilter())
  app.useGlobalInterceptors(new TransformInterceptor())

  await app.listen(3000)
}

bootstrap()

// 7. NestJS with WebSocket Support
// src/websocket/websocket.gateway.ts
import {
  WebSocketGateway,
  SubscribeMessage,
  WebSocketServer,
  OnGatewayInit,
  OnGatewayConnection,
  OnGatewayDisconnect,
  ConnectedSocket,
  MessageBody,
} from '@nestjs/websockets'
import { Server } from 'socket.io'

export interface ClientData {
  id: string
  name: string
  room?: string
}

export interface MessageData {
  text: string
  sender: string
  timestamp: string
  room?: string
}

@WebSocketGateway({ cors: { origin: '*' } })
export class WebSocketGateway implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect {
  @WebSocketServer() server: Server
  private clients: Map<string, ClientData> = new Map()

  afterInit(server: Server) {
    console.log('WebSocket Gateway initialized')
  }

  handleConnection(client: any) {
    console.log(`Client connected: ${client.id}`)
    this.clients.set(client.id, {
      id: client.id,
      name: `User${client.id.substr(-4)}`
    })

    client.emit('connected', {
      message: 'Connected to chat server',
      clientId: client.id
    })
  }

  handleDisconnect(client: any) {
    console.log(`Client disconnected: ${client.id}`)
    const clientData = this.clients.get(client.id)
    this.clients.delete(client.id)

    if (clientData) {
      client.broadcast.emit('userLeft', {
        message: `${clientData.name} left the chat`,
        user: clientData
      })
    }
  }

  @SubscribeMessage('joinRoom')
  handleJoinRoom(
    @MessageBody() data: { room: string },
    @ConnectedSocket() client: any,
  ) {
    const clientData = this.clients.get(client.id)
    if (clientData) {
      clientData.room = data.room
      client.join(data.room)

      client.emit('joinedRoom', {
        room: data.room,
        message: `Joined room: ${data.room}`
      })

      client.to(data.room).emit('userJoinedRoom', {
        message: `${clientData.name} joined the room`,
        user: clientData
      })
    }
  }

  @SubscribeMessage('sendMessage')
  handleMessage(
    @MessageBody() data: { text: string; room?: string },
    @ConnectedSocket() client: any,
  ) {
    const clientData = this.clients.get(client.id)
    if (!clientData) return

    const message: MessageData = {
      text: data.text,
      sender: clientData.name,
      timestamp: new Date().toISOString(),
      room: data.room
    }

    if (data.room) {
      this.server.to(data.room).emit('newMessage', message)
    } else {
      client.broadcast.emit('newMessage', message)
    }

    client.emit('messageSent', message)
  }

  @SubscribeMessage('getUsers')
  handleGetUsers(@ConnectedSocket() client: any) {
    const users = Array.from(this.clients.values())
    client.emit('usersList', users)
  }
}

// src/websocket/websocket.module.ts
import { Module } from '@nestjs/common'
import { WebSocketGateway } from './websocket.gateway'

@Module({
  providers: [WebSocketGateway],
  exports: [WebSocketGateway],
})
export class WebSocketModule {}

// 8. NestJS Configuration and Environment
// src/config/configuration.ts
export default () => ({
  port: parseInt(process.env.PORT, 10) || 3000,
  database: {
    host: process.env.DATABASE_HOST || 'localhost',
    port: parseInt(process.env.DATABASE_PORT, 10) || 5432,
    username: process.env.DATABASE_USERNAME || 'postgres',
    password: process.env.DATABASE_PASSWORD || 'password',
    database: process.env.DATABASE_NAME || 'nestjs_db'
  },
  jwt: {
    secret: process.env.JWT_SECRET || 'default-secret',
    expiresIn: process.env.JWT_EXPIRES_IN || '1h'
  },
  redis: {
    host: process.env.REDIS_HOST || 'localhost',
    port: parseInt(process.env.REDIS_PORT, 10) || 6379,
    password: process.env.REDIS_PASSWORD || undefined
  }
})

// src/config/config.module.ts
import { Module } from '@nestjs/common'
import { ConfigModule, ConfigService } from '@nestjs/config'
import configuration from './configuration'

@Module({
  imports: [ConfigModule.forRoot({
    load: [configuration],
    isGlobal: true
  })],
  providers: [ConfigService],
  exports: [ConfigService],
})
export class AppConfigModule {}

// 9. NestJS Testing
// src/users/users.service.spec.ts
import { Test, TestingModule } from '@nestjs/testing'
import { UsersService } from './users.service'
import { CreateUserDto } from './dto'

describe('UsersService', () => {
  let service: UsersService

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [UsersService],
    }).compile()

    service = module.get<UsersService>(UsersService)
  })

  it('should be defined', () => {
    expect(service).toBeDefined()
  })

  describe('create', () => {
    it('should create a user successfully', () => {
      const createUserDto: CreateUserDto = {
        name: 'John Doe',
        email: '[email protected]',
        age: 30
      }

      const user = service.create(createUserDto)

      expect(user).toHaveProperty('id')
      expect(user.name).toBe(createUserDto.name)
      expect(user.email).toBe(createUserDto.email)
      expect(user.age).toBe(createUserDto.age)
      expect(user).toHaveProperty('createdAt')
      expect(user).toHaveProperty('updatedAt')
    })

    it('should auto-increment user ID', () => {
      const user1 = service.create({ name: 'User 1', email: '[email protected]' })
      const user2 = service.create({ name: 'User 2', email: '[email protected]' })

      expect(user2.id).toBe(user1.id + 1)
    })
  })

  describe('findAll', () => {
    it('should return empty array when no users exist', () => {
      const users = service.findAll()
      expect(users).toEqual([])
    })

    it('should return all users', () => {
      const user1 = service.create({ name: 'User 1', email: '[email protected]' })
      const user2 = service.create({ name: 'User 2', email: '[email protected]' })

      const users = service.findAll()
      expect(users).toHaveLength(2)
      expect(users).toContainEqual(user1)
      expect(users).toContainEqual(user2)
    })
  })
})

// src/users/users.controller.e2e-spec.ts
import { Test, TestingModule } from '@nestjs/testing'
import { INestApplication } from '@nestjs/common'
import * as request from 'supertest'
import { AppModule } from '../app.module'

describe('UsersController (e2e)', () => {
  let app: INestApplication

  beforeEach(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [AppModule],
    }).compile()

    app = moduleFixture.createNestApplication()
    await app.init()
  })

  describe('/users (POST)', () => {
    it('should create a new user', () => {
      const createUserDto = {
        name: 'John Doe',
        email: '[email protected]'
      }

      return request(app.getHttpServer())
        .post('/api/users')
        .send(createUserDto)
        .expect(201)
        .expect((res) => {
          expect(res.body.name).toBe(createUserDto.name)
          expect(res.body.email).toBe(createUserDto.email)
          expect(res.body).toHaveProperty('id')
          expect(res.body).toHaveProperty('createdAt')
        })
    })

    it('should return 400 for invalid data', () => {
      const invalidUserDto = {
        name: '',
        email: 'invalid-email'
      }

      return request(app.getHttpServer())
        .post('/api/users')
        .send(invalidUserDto)
        .expect(400)
    })
  })

  describe('/users (GET)', () => {
    it('should return array of users', () => {
      return request(app.getHttpServer())
        .get('/api/users')
        .expect(200)
        .expect((res) => {
          expect(Array.isArray(res.body)).toBe(true)
        })
    })
  })
})

// 10. Package.json Configuration
{
  "name": "nestjs-app",
  "version": "0.0.1",
  "description": "NestJS application example",
  "author": "",
  "private": true,
  "license": "UNLICENSED",
  "scripts": {
    "build": "nest build",
    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
    "start": "nest start",
    "start:dev": "nest start --watch",
    "start:debug": "nest start --debug --watch",
    "start:prod": "node dist/main",
    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
    "test": "jest",
    "test:watch": "jest --watch",
    "test:cov": "jest --coverage",
    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
    "test:e2e": "jest --config ./test/jest-e2e.json"
  },
  "dependencies": {
    "@nestjs/common": "^10.0.0",
    "@nestjs/core": "^10.0.0",
    "@nestjs/platform-express": "^10.0.0",
    "@nestjs/websockets": "^10.0.0",
    "@nestjs/config": "^3.0.0",
    "@nestjs/platform-socket.io": "^10.0.0",
    "class-validator": "^0.14.0",
    "class-transformer": "^0.5.1",
    "reflect-metadata": "^0.1.13",
    "rxjs": "^7.8.1",
    "socket.io": "^4.7.2"
  },
  "devDependencies": {
    "@nestjs/cli": "^10.0.0",
    "@nestjs/schematics": "^10.0.0",
    "@nestjs/testing": "^10.0.0",
    "@types/express": "^4.17.17",
    "@types/jest": "^29.5.2",
    "@types/node": "^20.3.1",
    "@types/supertest": "^2.0.12",
    "@typescript-eslint/eslint-plugin": "^6.0.0",
    "@typescript-eslint/parser": "^6.0.0",
    "eslint": "^8.42.0",
    "eslint-config-prettier": "^9.0.0",
    "eslint-plugin-prettier": "^5.0.0",
    "jest": "^29.5.0",
    "prettier": "^3.0.0",
    "source-map-support": "^0.5.21",
    "supertest": "^6.3.3",
    "ts-jest": "^29.1.0",
    "ts-loader": "^9.4.3",
    "ts-node": "^10.9.1",
    "tsconfig-paths": "^4.2.0",
    "typescript": "^5.1.3"
  },
  "jest": {
    "moduleFileExtensions": [
      "js",
      "json",
      "ts"
    ],
    "rootDir": "src",
    "testRegex": ".*\.spec\.ts$",
    "transform": {
      "^.+\.(t|j)s$": "ts-jest"
    },
    "collectCoverageFrom": [
      "**/*.(t|j)s"
    ],
    "coverageDirectory": "../coverage",
    "testEnvironment": "node"
  }
}

// NestJS Modules and Services Examples

// 1. Basic Module Structure
// src/core/core.module.ts
import { Module } from '@nestjs/common'
import { ConfigModule } from '@nestjs/config'
import { LoggerModule } from '@nestjs/logger'
import { DatabaseModule } from './database/database.module'

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
      envFilePath: '.env'
    }),
    LoggerModule.forRoot({
      isGlobal: true
    }),
    DatabaseModule
  ],
  exports: [DatabaseModule]
})
export class CoreModule {}

// src/core/database/database.module.ts
import { Module } from '@nestjs/common'
import { DatabaseService } from './database.service'

@Module({
  providers: [DatabaseService],
  exports: [DatabaseService]
})
export class DatabaseModule {}

// src/core/database/database.service.ts
import { Injectable, OnModuleInit } from '@nestjs/common'
import { ConfigService } from '@nestjs/config'

@Injectable()
export class DatabaseService implements OnModuleInit {
  private connection: any

  constructor(private configService: ConfigService) {}

  async onModuleInit() {
    await this.connect()
  }

  private async connect() {
    console.log('Connecting to database...')
    // Database connection logic here
  }

  async query(sql: string, params?: any[]) {
    // Query execution logic here
    return { rows: [] }
  }

  async close() {
    // Connection cleanup logic here
  }
}

// 2. Feature Module Architecture
// src/users/users.module.ts
import { Module } from '@nestjs/common'
import { TypeOrmModule } from '@nestjs/typeorm'
import { UsersController } from './users.controller'
import { UsersService } from './users.service'
import { User } from './entities/user.entity'
import { UserProfileModule } from './user-profile/user-profile.module'

@Module({
  imports: [
    TypeOrmModule.forFeature([User]),
    UserProfileModule
  ],
  controllers: [UsersController],
  providers: [UsersService],
  exports: [UsersService]
})
export class UsersModule {}

// src/users/users.service.ts
import { Injectable, NotFoundException } from '@nestjs/common'
import { InjectRepository } from '@nestjs/typeorm'
import { Repository } from 'typeorm'
import { User } from './entities/user.entity'
import { CreateUserDto } from './dto/create-user.dto'
import { UpdateUserDto } from './dto/update-user.dto'
import { UserProfileService } from '../user-profile/user-profile.service'

@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>,
    private userProfileService: UserProfileService
  ) {}

  async create(createUserDto: CreateUserDto): Promise<User> {
    const user = this.userRepository.create(createUserDto)
    const savedUser = await this.userRepository.save(user)

    // Create user profile
    await this.userProfileService.create({
      userId: savedUser.id,
      bio: createUserDto.bio || ''
    })

    return savedUser
  }

  async findAll(): Promise<User[]> {
    return this.userRepository.find({
      relations: ['profile']
    })
  }

  async findOne(id: number): Promise<User> {
    const user = await this.userRepository.findOne({
      where: { id },
      relations: ['profile']
    })

    if (!user) {
      throw new NotFoundException(`User with ID ${id} not found`)
    }

    return user
  }

  async update(id: number, updateUserDto: UpdateUserDto): Promise<User> {
    const user = await this.findOne(id)
    Object.assign(user, updateUserDto)
    return this.userRepository.save(user)
  }

  async remove(id: number): Promise<void> {
    const user = await this.findOne(id)
    await this.userRepository.remove(user)
  }

  // Custom query methods
  async findByEmail(email: string): Promise<User | null> {
    return this.userRepository.findOne({
      where: { email },
      relations: ['profile']
    })
  }

  async findActiveUsers(): Promise<User[]> {
    return this.userRepository.find({
      where: { isActive: true },
      relations: ['profile']
    })
  }
}

// 3. Service Abstraction with Interfaces
// src/users/interfaces/user-service.interface.ts
import { User } from '../entities/user.entity'
import { CreateUserDto } from '../dto/create-user.dto'
import { UpdateUserDto } from '../dto/update-user.dto'

export interface IUsersService {
  create(createUserDto: CreateUserDto): Promise<User>
  findAll(): Promise<User[]>
  findOne(id: number): Promise<User>
  update(id: number, updateUserDto: UpdateUserDto): Promise<User>
  remove(id: number): Promise<void>
  findByEmail(email: string): Promise<User | null>
  findActiveUsers(): Promise<User[]>
}

// src/users/users.service.ts (implementing interface)
import { Injectable, NotFoundException } from '@nestjs/common'
import { InjectRepository } from '@nestjs/typeorm'
import { Repository } from 'typeorm'
import { User } from './entities/user.entity'
import { CreateUserDto, UpdateUserDto } from './dto'
import { IUsersService } from './interfaces/user-service.interface'

@Injectable()
export class UsersService implements IUsersService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>
  ) {}

  async create(createUserDto: CreateUserDto): Promise<User> {
    // Implementation
  }

  async findAll(): Promise<User[]> {
    return this.userRepository.find()
  }

  async findOne(id: number): Promise<User> {
    const user = await this.userRepository.findOne({ where: { id } })
    if (!user) {
      throw new NotFoundException(`User with ID ${id} not found`)
    }
    return user
  }

  async update(id: number, updateUserDto: UpdateUserDto): Promise<User> {
    const user = await this.findOne(id)
    Object.assign(user, updateUserDto)
    return this.userRepository.save(user)
  }

  async remove(id: number): Promise<void> {
    const user = await this.findOne(id)
    await this.userRepository.remove(user)
  }

  async findByEmail(email: string): Promise<User | null> {
    return this.userRepository.findOne({ where: { email } })
  }

  async findActiveUsers(): Promise<User[]> {
    return this.userRepository.find({ where: { isActive: true } })
  }
}

// 4. Provider Registration and Custom Providers
// src/cache/cache.module.ts
import { Module } from '@nestjs/common'
import { CacheService } from './cache.service'
import { REDIS_PROVIDER } from './cache.constants'

// Custom provider factory
export const redisProvider = {
  provide: REDIS_PROVIDER,
  useFactory: async () => {
    const Redis = require('ioredis')
    const redis = new Redis({
      host: process.env.REDIS_HOST || 'localhost',
      port: parseInt(process.env.REDIS_PORT) || 6379,
      password: process.env.REDIS_PASSWORD
    })

    await redis.ping()
    return redis
  }
}

@Module({
  providers: [
    CacheService,
    redisProvider
  ],
  exports: [CacheService]
})
export class CacheModule {}

// src/cache/cache.service.ts
import { Injectable, Inject } from '@nestjs/common'
import { REDIS_PROVIDER } from './cache.constants'

@Injectable()
export class CacheService {
  constructor(@Inject(REDIS_PROVIDER) private readonly redis: any) {}

  async get(key: string): Promise<string | null> {
    return this.redis.get(key)
  }

  async set(key: string, value: string, ttl?: number): Promise<void> {
    if (ttl) {
      await this.redis.setex(key, ttl, value)
    } else {
      await this.redis.set(key, value)
    }
  }

  async del(key: string): Promise<void> {
    await this.redis.del(key)
  }

  async exists(key: string): Promise<boolean> {
    const result = await this.redis.exists(key)
    return result === 1
  }

  async clear(): Promise<void> {
    await this.redis.flushall()
  }
}

// 5. Async Provider Registration
// src/async-connection/async-connection.module.ts
import { Module } from '@nestjs/common'

export const ASYNC_CONNECTION_PROVIDER = 'ASYNC_CONNECTION_PROVIDER'

export const asyncConnectionProvider = {
  provide: ASYNC_CONNECTION_PROVIDER,
  useFactory: async (configService: ConfigService) => {
    // Simulate async connection setup
    await new Promise(resolve => setTimeout(resolve, 1000))

    return {
      connect: () => console.log('Connected asynchronously'),
      disconnect: () => console.log('Disconnected asynchronously')
    }
  },
  inject: [ConfigService]
}

@Module({
  providers: [asyncConnectionProvider],
  exports: [ASYNC_CONNECTION_PROVIDER]
})
export class AsyncConnectionModule {}

// 6. Circular Dependency Resolution
// src/auth/auth.service.ts
import { Injectable, forwardRef, Inject } from '@nestjs/common'
import { UsersService } from '../users/users.service'

@Injectable()
export class AuthService {
  constructor(
    @Inject(forwardRef(() => UsersService))
    private usersService: UsersService
  ) {}

  async validateUser(email: string, password: string) {
    const user = await this.usersService.findByEmail(email)
    if (!user) {
      return null
    }

    // Password validation logic here
    const isValid = await this.validatePassword(password, user.password)
    return isValid ? user : null
  }

  private async validatePassword(password: string, hashedPassword: string) {
    // Password validation logic
    return password === hashedPassword // Simplified
  }

  async login(user: any) {
    return {
      access_token: 'jwt-token',
      user
    }
  }
}

// src/users/users.service.ts (updated to avoid circular dependency)
import { Injectable } from '@nestjs/common'
import { InjectRepository } from '@nestjs/typeorm'
import { Repository } from 'typeorm'
import { User } from './entities/user.entity'

@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>
  ) {}

  async findByEmail(email: string): Promise<User | null> {
    return this.userRepository.findOne({ where: { email } })
  }

  // Other methods...
}

// 7. Service Decorators and Scopes
// src/scoped/scoped.service.ts
import { Injectable, Scope } from '@nestjs/common'

@Injectable({ scope: Scope.REQUEST })
export class ScopedService {
  private requestId: string

  constructor() {
    this.requestId = Math.random().toString(36).substr(2, 9)
  }

  getRequestId(): string {
    return this.requestId
  }

  processData(data: any): any {
    return {
      requestId: this.requestId,
      processed: true,
      data,
      timestamp: new Date().toISOString()
    }
  }
}

// src/singleton/singleton.service.ts
import { Injectable } from '@nestjs/common'

@Injectable()
export class SingletonService {
  private static instanceCount = 0
  private instanceId: number

  constructor() {
    SingletonService.instanceCount++
    this.instanceId = SingletonService.instanceCount
  }

  getInstanceId(): number {
    return this.instanceId
  }

  getTotalInstances(): number {
    return SingletonService.instanceCount
  }
}

// 8. Service with Repository Pattern
// src/users/repositories/user.repository.ts
import { Injectable } from '@nestjs/common'
import { InjectRepository } from '@nestjs/typeorm'
import { Repository } from 'typeorm'
import { User } from '../entities/user.entity'

export interface IUserRepository {
  create(userData: Partial<User>): Promise<User>
  findById(id: number): Promise<User | null>
  findByEmail(email: string): Promise<User | null>
  findAll(): Promise<User[]>
  update(id: number, userData: Partial<User>): Promise<User>
  delete(id: number): Promise<void>
  findActiveUsers(): Promise<User[]>
}

@Injectable()
export class UserRepository implements IUserRepository {
  constructor(
    @InjectRepository(User)
    private readonly repository: Repository<User>
  ) {}

  async create(userData: Partial<User>): Promise<User> {
    const user = this.repository.create(userData)
    return this.repository.save(user)
  }

  async findById(id: number): Promise<User | null> {
    return this.repository.findOne({ where: { id } })
  }

  async findByEmail(email: string): Promise<User | null> {
    return this.repository.findOne({ where: { email } })
  }

  async findAll(): Promise<User[]> {
    return this.repository.find()
  }

  async update(id: number, userData: Partial<User>): Promise<User> {
    await this.repository.update(id, userData)
    return this.findById(id)
  }

  async delete(id: number): Promise<void> {
    await this.repository.delete(id)
  }

  async findActiveUsers(): Promise<User[]> {
    return this.repository.find({ where: { isActive: true } })
  }
}

// src/users/users.service.ts (using repository)
import { Injectable } from '@nestjs/common'
import { CreateUserDto, UpdateUserDto } from './dto'
import { UserRepository, IUserRepository } from './repositories/user.repository'

@Injectable()
export class UsersService {
  constructor(private readonly userRepository: IUserRepository) {}

  async create(createUserDto: CreateUserDto): Promise<User> {
    return this.userRepository.create(createUserDto)
  }

  async findAll(): Promise<User[]> {
    return this.userRepository.findAll()
  }

  async findOne(id: number): Promise<User> {
    const user = await this.userRepository.findById(id)
    if (!user) {
      throw new NotFoundException(`User with ID ${id} not found`)
    }
    return user
  }

  async update(id: number, updateUserDto: UpdateUserDto): Promise<User> {
    return this.userRepository.update(id, updateUserDto)
  }

  async remove(id: number): Promise<void> {
    await this.userRepository.delete(id)
  }

  async findByEmail(email: string): Promise<User | null> {
    return this.userRepository.findByEmail(email)
  }

  async findActiveUsers(): Promise<User[]> {
    return this.userRepository.findActiveUsers()
  }
}

// 9. Service with Factory Pattern
// src/factories/notification.factory.ts
import { Injectable } from '@nestjs/common'

export interface NotificationProvider {
  send(message: string, recipient: string): Promise<boolean>
}

@Injectable()
export class EmailNotificationProvider implements NotificationProvider {
  async send(message: string, recipient: string): Promise<boolean> {
    console.log(`Sending email to ${recipient}: ${message}`)
    return true
  }
}

@Injectable()
export class SMSNotificationProvider implements NotificationProvider {
  async send(message: string, recipient: string): Promise<boolean> {
    console.log(`Sending SMS to ${recipient}: ${message}`)
    return true
  }
}

@Injectable()
export class PushNotificationProvider implements NotificationProvider {
  async send(message: string, recipient: string): Promise<boolean> {
    console.log(`Sending push notification to ${recipient}: ${message}`)
    return true
  }
}

export class NotificationFactory {
  static createProvider(type: 'email' | 'sms' | 'push'): NotificationProvider {
    switch (type) {
      case 'email':
        return new EmailNotificationProvider()
      case 'sms':
        return new SMSNotificationProvider()
      case 'push':
        return new PushNotificationProvider()
      default:
        throw new Error(`Unknown notification provider: ${type}`)
    }
  }
}

// src/notification/notification.service.ts
import { Injectable } from '@nestjs/common'
import { NotificationFactory, NotificationProvider } from '../factories/notification.factory'

@Injectable()
export class NotificationService {
  private providers: Map<string, NotificationProvider> = new Map()

  constructor() {
    // Register default providers
    this.providers.set('email', NotificationFactory.createProvider('email'))
    this.providers.set('sms', NotificationFactory.createProvider('sms'))
    this.providers.set('push', NotificationFactory.createProvider('push'))
  }

  async sendNotification(
    type: 'email' | 'sms' | 'push',
    message: string,
    recipient: string
  ): Promise<boolean> {
    const provider = this.providers.get(type)
    if (!provider) {
      throw new Error(`Notification provider '${type}' not found`)
    }

    return provider.send(message, recipient)
  }

  registerProvider(type: string, provider: NotificationProvider): void {
    this.providers.set(type, provider)
  }

  async sendMultiChannelNotification(
    message: string,
    recipient: string,
    channels: string[] = ['email', 'sms']
  ): Promise<boolean[]> {
    const results = await Promise.all(
      channels.map(async (channel) => {
        try {
          return await this.sendNotification(channel as any, message, recipient)
        } catch (error) {
          console.error(`Failed to send ${channel} notification:`, error)
          return false
        }
      })
    )

    return results
  }
}

// 10. Service with Event Pattern
// src/events/events.module.ts
import { Module } from '@nestjs/common'
import { EventEmitterModule } from '@nestjs/event-emitter'
import { UserEventsService } from './services/user-events.service'
import { UserCreatedListener } from './listeners/user-created.listener'

@Module({
  imports: [EventEmitterModule.forRoot()],
  providers: [UserEventsService, UserCreatedListener],
  exports: [UserEventsService]
})
export class EventsModule {}

// src/events/services/user-events.service.ts
import { Injectable } from '@nestjs/common'
import { EventEmitter2 } from '@nestjs/event-emitter'

export interface UserCreatedEvent {
  userId: number
  email: string
  name: string
}

export interface UserDeletedEvent {
  userId: number
  deletedAt: Date
}

@Injectable()
export class UserEventsService {
  constructor(private eventEmitter: EventEmitter2) {}

  emitUserCreated(event: UserCreatedEvent) {
    this.eventEmitter.emit('user.created', event)
  }

  emitUserDeleted(event: UserDeletedEvent) {
    this.eventEmitter.emit('user.deleted', event)
  }

  emitUserUpdated(userId: number, changes: any) {
    this.eventEmitter.emit('user.updated', {
      userId,
      changes,
      updatedAt: new Date()
    })
  }
}

// src/events/listeners/user-created.listener.ts
import { Injectable, Logger } from '@nestjs/common'
import { OnEvent } from '@nestjs/event-emitter'
import { UserCreatedEvent } from '../services/user-events.service'
import { NotificationService } from '../notification/notification.service'
import { EmailService } from '../email/email.service'

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

  constructor(
    private readonly notificationService: NotificationService,
    private readonly emailService: EmailService
  ) {}

  @OnEvent('user.created')
  async handleUserCreatedEvent(event: UserCreatedEvent) {
    this.logger.log(`Handling user created event for user ID: ${event.userId}`)

    // Send welcome email
    await this.emailService.sendWelcomeEmail(event.email, event.name)

    // Send welcome notification
    await this.notificationService.sendNotification(
      'push',
      `Welcome ${event.name}! Your account has been created successfully.`,
      `user_${event.userId}`
    )

    // Log analytics
    await this.logUserCreation(event)
  }

  private async logUserCreation(event: UserCreatedEvent) {
    // Analytics logging logic
    this.logger.log(`User analytics logged for ID: ${event.userId}`)
  }
}

// NestJS Controllers and DTOs Examples

// 1. Basic Controller Structure
// src/controllers/app.controller.ts
import { Controller, Get, Post, Put, Delete, Param, Query, Body, HttpStatus, HttpCode } from '@nestjs/common'
import { AppService } from '../services/app.service'
import { CreateDto, UpdateDto, QueryDto } from '../dto'

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getRoot(): string {
    return this.appService.getRoot()
  }

  @Get('health')
  @HttpCode(HttpStatus.OK)
  getHealthCheck() {
    return {
      status: 'OK',
      timestamp: new Date().toISOString(),
      uptime: process.uptime()
    }
  }
}

// 2. RESTful Controller with Full CRUD Operations
// src/products/products.controller.ts
import {
  Controller,
  Get,
  Post,
  Put,
  Delete,
  Patch,
  Param,
  Query,
  Body,
  Headers,
  Ip,
  Session,
  UseGuards,
  UseInterceptors,
  UseFilters,
  HttpStatus,
  NotFoundException,
  BadRequestException
} from '@nestjs/common'
import { ProductsService } from '../services/products.service'
import { CreateProductDto, UpdateProductDto, ProductQueryDto } from '../dto'
import { JwtAuthGuard } from '../guards/jwt-auth.guard'
import { LoggingInterceptor } from '../interceptors/logging.interceptor'
import { HttpExceptionFilter } from '../filters/http-exception.filter'
import { CacheInterceptor } from '@nestjs/cache-manager'
import { CacheKey } from '../decorators/cache-key.decorator'

@Controller('products')
@UseGuards(JwtAuthGuard)
@UseInterceptors(LoggingInterceptor, CacheInterceptor)
@UseFilters(HttpExceptionFilter)
export class ProductsController {
  constructor(private readonly productsService: ProductsService) {}

  @Post()
  async create(@Body() createProductDto: CreateProductDto) {
    try {
      const product = await this.productsService.create(createProductDto)
      return {
        success: true,
        data: product,
        message: 'Product created successfully'
      }
    } catch (error) {
      throw new BadRequestException(error.message)
    }
  }

  @Get()
  @CacheKey('products')
  async findAll(@Query() query: ProductQueryDto) {
    const { page = 1, limit = 10, search, category, sortBy = 'createdAt', sortOrder = 'desc' } = query

    const result = await this.productsService.findAll({
      page: +page,
      limit: +limit,
      search,
      category,
      sortBy,
      sortOrder
    })

    return {
      success: true,
      data: result.products,
      pagination: {
        page: result.page,
        limit: result.limit,
        total: result.total,
        totalPages: Math.ceil(result.total / limit)
      }
    }
  }

  @Get(':id')
  async findOne(
    @Param('id', ParseIntPipe) id: number,
    @Headers('accept-language') acceptLanguage: string,
    @Ip() ip: string
  ) {
    const product = await this.productsService.findOne(id)

    if (!product) {
      throw new NotFoundException(`Product with ID ${id} not found`)
    }

    // Log access
    console.log(`Product ${id} accessed from ${ip} with language: ${acceptLanguage}`)

    return {
      success: true,
      data: product
    }
  }

  @Put(':id')
  async update(
    @Param('id', ParseIntPipe) id: number,
    @Body() updateProductDto: UpdateProductDto
  ) {
    const product = await this.productsService.update(id, updateProductDto)

    if (!product) {
      throw new NotFoundException(`Product with ID ${id} not found`)
    }

    return {
      success: true,
      data: product,
      message: 'Product updated successfully'
    }
  }

  @Patch(':id')
  async partialUpdate(
    @Param('id', ParseIntPipe) id: number,
    @Body() partialUpdateDto: Partial<UpdateProductDto>
  ) {
    const product = await this.productsService.partialUpdate(id, partialUpdateDto)

    if (!product) {
      throw new NotFoundException(`Product with ID ${id} not found`)
    }

    return {
      success: true,
      data: product,
      message: 'Product partially updated successfully'
    }
  }

  @Delete(':id')
  @HttpCode(HttpStatus.NO_CONTENT)
  async remove(@Param('id', ParseIntPipe) id: number) {
    const result = await this.productsService.remove(id)

    if (!result) {
      throw new NotFoundException(`Product with ID ${id} not found`)
    }
  }

  @Post(':id/like')
  async likeProduct(
    @Param('id', ParseIntPipe) id: number,
    @Session() session: Record<string, any>
  ) {
    const userId = session.userId || 'anonymous'
    const result = await this.productsService.likeProduct(id, userId)

    return {
      success: true,
      data: result,
      message: 'Product liked successfully'
    }
  }

  @Get(':id/reviews')
  async getProductReviews(
    @Param('id', ParseIntPipe) id: number,
    @Query('page', ParseIntPipe) page: number = 1,
    @Query('limit', ParseIntPipe) limit: number = 10
  ) {
    const reviews = await this.productsService.getProductReviews(id, page, limit)

    return {
      success: true,
      data: reviews,
      pagination: {
        page,
        limit,
        total: reviews.length
      }
    }
  }
}

// 3. Controller with Custom Decorators
// src/decorators/user.decorator.ts
import { createParamDecorator, ExecutionContext } from '@nestjs/common'

export const User = createParamDecorator(
  (data: string, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest()
    const user = request.user

    return data ? user?.[data] : user
  },
)

export const IpAddress = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest()
    return request.ip || request.headers['x-forwarded-for'] || request.connection.remoteAddress
  },
)

// src/decorators/pagination.decorator.ts
import { createParamDecorator, ExecutionContext } from '@nestjs/common'

export interface Pagination {
  page: number
  limit: number
  offset: number
}

export const Pagination = createParamDecorator(
  (defaultLimit: number = 10, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest()
    const page = parseInt(request.query.page) || 1
    const limit = parseInt(request.query.limit) || defaultLimit

    return {
      page,
      limit,
      offset: (page - 1) * limit
    }
  },
)

// src/controllers/user.controller.ts
import { Controller, Get, Post, Put, Delete, Param, Body } from '@nestjs/common'
import { UserService } from '../services/user.service'
import { CreateUserDto, UpdateUserDto } from '../dto'
import { User, IpAddress, Pagination } from '../decorators'

@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Get('profile')
  getUserProfile(@User() user: any) {
    return {
      success: true,
      data: user
    }
  }

  @Get('activity')
  getUserActivity(@User('id') userId: number, @Pagination(20) pagination: Pagination) {
    return this.userService.getUserActivity(userId, pagination)
  }

  @Post()
  async createUser(
    @Body() createUserDto: CreateUserDto,
    @IpAddress() ip: string
  ) {
    const user = await this.userService.create({
      ...createUserDto,
      registrationIp: ip
    })

    return {
      success: true,
      data: user,
      message: 'User created successfully'
    }
  }
}

// 4. DTOs with Validation
// src/dto/create-product.dto.ts
import {
  IsString,
  IsNumber,
  IsOptional,
  IsPositive,
  IsEmail,
  IsUrl,
  IsArray,
  IsEnum,
  MinLength,
  MaxLength,
  Matches,
  IsDateString
} from 'class-validator'

export enum ProductStatus {
  ACTIVE = 'active',
  INACTIVE = 'inactive',
  DRAFT = 'draft'
}

export class CreateProductDto {
  @IsString()
  @MinLength(3, { message: 'Name must be at least 3 characters long' })
  @MaxLength(100, { message: 'Name must not exceed 100 characters' })
  name: string;

  @IsString()
  @MinLength(10, { message: 'Description must be at least 10 characters long' })
  description: string;

  @IsNumber()
  @IsPositive({ message: 'Price must be a positive number' })
  price: number;

  @IsOptional()
  @IsNumber()
  @IsPositive({ message: 'Discount must be a positive number' })
  discount?: number;

  @IsOptional()
  @IsString()
  @IsEnum(ProductStatus, { message: 'Invalid status value' })
  status?: ProductStatus;

  @IsOptional()
  @IsArray()
  @IsString({ each: true, message: 'Each tag must be a string' })
  tags?: string[];

  @IsOptional()
  @IsUrl({}, { message: 'Image URL must be a valid URL' })
  imageUrl?: string;

  @IsOptional()
  @IsString()
  category?: string;

  @IsOptional()
  @IsNumber()
  @IsPositive({ message: 'Stock must be a positive number' })
  stock?: number;

  @IsOptional()
  @IsString()
  @Matches(/^[a-zA-Z0-9-]+$/, { message: 'SKU can only contain letters, numbers, and hyphens' })
  sku?: string;

  @IsOptional()
  @IsDateString({}, { message: 'Launch date must be a valid ISO date string' })
  launchDate?: string;
}

// src/dto/update-product.dto.ts
import { PartialType } from '@nestjs/swagger'
import { CreateProductDto } from './create-product.dto'

export class UpdateProductDto extends PartialType(CreateProductDto) {}

// src/dto/product-query.dto.ts
import {
  IsOptional,
  IsString,
  IsNumber,
  IsEnum,
  IsPositive,
  Min,
  Max
} from 'class-validator'
import { Transform } from 'class-transformer'
import { ProductStatus } from './create-product.dto'

export class ProductQueryDto {
  @IsOptional()
  @Transform(({ value }) => parseInt(value))
  @IsNumber()
  @IsPositive()
  @Min(1)
  page?: number = 1;

  @IsOptional()
  @Transform(({ value }) => parseInt(value))
  @IsNumber()
  @IsPositive()
  @Max(100)
  limit?: number = 10;

  @IsOptional()
  @IsString()
  search?: string;

  @IsOptional()
  @IsString()
  category?: string;

  @IsOptional()
  @IsEnum(ProductStatus)
  status?: ProductStatus;

  @IsOptional()
  @IsEnum(['createdAt', 'updatedAt', 'price', 'name'])
  sortBy?: string = 'createdAt';

  @IsOptional()
  @IsEnum(['asc', 'desc'])
  sortOrder?: 'asc' | 'desc' = 'desc';

  @IsOptional()
  @Transform(({ value }) => value === 'true')
  includeDeleted?: boolean;

  @IsOptional()
  @Transform(({ value }) => parseFloat(value))
  @IsNumber()
  @IsPositive()
  minPrice?: number;

  @IsOptional()
  @Transform(({ value }) => parseFloat(value))
  @IsNumber()
  @IsPositive()
  maxPrice?: number;
}

// 5. Nested DTOs for Complex Objects
// src/dto/create-order.dto.ts
import {
  IsString,
  IsEmail,
  IsArray,
  IsNumber,
  IsPositive,
  ValidateNested,
  ArrayNotEmpty
} from 'class-validator'
import { Type } from 'class-transformer'

export class OrderItemDto {
  @IsNumber()
  @IsPositive()
  productId: number;

  @IsNumber()
  @IsPositive()
  quantity: number;

  @IsOptional()
  @IsNumber()
  @IsPositive()
  unitPrice?: number;
}

export class ShippingAddressDto {
  @IsString()
  street: string;

  @IsString()
  city: string;

  @IsString()
  state: string;

  @IsString()
  @Matches(/^[0-9]{5}(-[0-9]{4})?$/, { message: 'Invalid postal code format' })
  postalCode: string;

  @IsString()
  country: string;

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

export class CreateOrderDto {
  @IsEmail({}, { message: 'Invalid email format' })
  customerEmail: string;

  @IsString()
  customerName: string;

  @IsArray()
  @ArrayNotEmpty({ message: 'Order must contain at least one item' })
  @ValidateNested({ each: true })
  @Type(() => OrderItemDto)
  items: OrderItemDto[];

  @ValidateNested()
  @Type(() => ShippingAddressDto)
  shippingAddress: ShippingAddressDto;

  @IsOptional()
  @IsString()
  @IsEnum(['standard', 'express', 'overnight'])
  shippingMethod?: string;

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

// 6. DTOs with Class Transformer
// src/dto/user.dto.ts
import {
  IsString,
  IsEmail,
  IsOptional,
  IsBoolean,
  IsDateString,
  IsEnum
} from 'class-validator'
import { Transform, Expose } from 'class-transformer'
import { UserRole } from '../enums/user-role.enum'

export class CreateUserDto {
  @IsString()
  @Transform(({ value }) => value?.trim())
  firstName: string;

  @IsString()
  @Transform(({ value }) => value?.trim())
  lastName: string;

  @IsEmail({}, { message: 'Invalid email format' })
  @Transform(({ value }) => value?.toLowerCase().trim())
  email: string;

  @IsString()
  @MinLength(8, { message: 'Password must be at least 8 characters long' })
  @Matches(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]/, {
    message: 'Password must contain at least one uppercase letter, one lowercase letter, one number, and one special character'
  })
  password: string;

  @IsOptional()
  @IsDateString()
  birthDate?: string;

  @IsOptional()
  @IsEnum(UserRole)
  role?: UserRole = UserRole.USER;

  @IsOptional()
  @IsBoolean()
  @Transform(({ value }) => value === 'true')
  isActive?: boolean = true;

  @IsOptional()
  @IsString()
  @Transform(({ value }) => value?.trim())
  phone?: string;

  @IsOptional()
  @Transform(({ value }) => value?.split(',').map((tag: string) => tag.trim()).filter(Boolean))
  tags?: string[];
}

export class UserResponseDto {
  @Expose()
  id: number;

  @Expose()
  email: string;

  @Expose()
  firstName: string;

  @Expose()
  lastName: string;

  @Expose()
  fullName: string;

  @Expose()
  role: UserRole;

  @Expose()
  isActive: boolean;

  @Expose()
  birthDate: string;

  @Expose()
  phone: string;

  @Expose()
  tags: string[];

  @Expose()
  createdAt: string;

  @Expose()
  updatedAt: string;

  @Expose()
  lastLoginAt?: string;
}

// src/dto/user-search.dto.ts
import { IsOptional, IsString, IsBoolean, IsEnum } from 'class-validator'
import { Transform } from 'class-transformer'

export enum SortField {
  NAME = 'name',
  EMAIL = 'email',
  CREATED_AT = 'createdAt',
  LAST_LOGIN = 'lastLoginAt'
}

export enum SortOrder {
  ASC = 'asc',
  DESC = 'desc'
}

export class UserSearchDto {
  @IsOptional()
  @IsString()
  @Transform(({ value }) => value?.trim())
  search?: string;

  @IsOptional()
  @IsString()
  @Transform(({ value }) => value?.trim())
  email?: string;

  @IsOptional()
  @IsString()
  @Transform(({ value }) => value?.trim())
  name?: string;

  @IsOptional()
  @IsBoolean()
  @Transform(({ value }) => value === 'true')
  isActive?: boolean;

  @IsOptional()
  @IsEnum(SortField)
  sortBy?: SortField = SortField.CREATED_AT;

  @IsOptional()
  @IsEnum(SortOrder)
  sortOrder?: SortOrder = SortOrder.DESC;

  @IsOptional()
  @Transform(({ value }) => parseInt(value))
  @IsNumber()
  page?: number = 1;

  @IsOptional()
  @Transform(({ value }) => parseInt(value))
  @IsNumber()
  limit?: number = 10;

  @IsOptional()
  @Transform(({ value }) => value?.split(',').map((tag: string) => tag.trim()))
  tags?: string[];
}

// 7. Controller with Response Transformation
// src/controllers/api/v1/users.controller.ts
import {
  Controller,
  Get,
  Post,
  Put,
  Delete,
  Param,
  Body,
  HttpCode,
  HttpStatus,
  UseGuards,
  UseInterceptors
} from '@nestjs/common'
import { UserService } from '../../../services/user.service'
import { CreateUserDto, UpdateUserDto, UserResponseDto, UserSearchDto } from '../../../dto'
import { JwtAuthGuard } from '../../../guards/jwt-auth.guard'
import { TransformInterceptor } from '../../../interceptors/transform.interceptor'
import { Serialize } from '../../../decorators/serialize.decorator'

@Controller('api/v1/users')
@UseGuards(JwtAuthGuard)
@UseInterceptors(TransformInterceptor)
export class ApiV1UsersController {
  constructor(private readonly userService: UserService) {}

  @Post()
  @Serialize(UserResponseDto)
  async create(@Body() createUserDto: CreateUserDto) {
    const user = await this.userService.create(createUserDto)
    return {
      success: true,
      data: user,
      message: 'User created successfully'
    }
  }

  @Get()
  @Serialize(UserResponseDto)
  async findAll(@Query() query: UserSearchDto) {
    const { users, pagination } = await this.userService.findAll(query)
    return {
      success: true,
      data: users,
      pagination
    }
  }

  @Get(':id')
  @Serialize(UserResponseDto)
  async findOne(@Param('id') id: string) {
    const user = await this.userService.findOne(+id)
    return {
      success: true,
      data: user
    }
  }

  @Put(':id')
  @Serialize(UserResponseDto)
  async update(
    @Param('id') id: string,
    @Body() updateUserDto: UpdateUserDto
  ) {
    const user = await this.userService.update(+id, updateUserDto)
    return {
      success: true,
      data: user,
      message: 'User updated successfully'
    }
  }

  @Delete(':id')
  @HttpCode(HttpStatus.NO_CONTENT)
  async remove(@Param('id') id: string) {
    await this.userService.remove(+id)
  }
}

// 8. Controller with File Upload
// src/controllers/upload.controller.ts
import {
  Controller,
  Post,
  UseInterceptors,
  UploadedFile,
  UploadedFiles,
  Body,
  HttpCode,
  HttpStatus,
  ParseFilePipe,
  MaxFileSizeValidator,
  FileTypeValidator,
  ParseFilePipeBuilder
} from '@nestjs/common'
import { FileInterceptor, FilesInterceptor } from '@nestjs/platform-express'
import { UploadService } from '../services/upload.service'
import { CreateUploadDto } from '../dto/upload.dto'

@Controller('upload')
export class UploadController {
  constructor(private readonly uploadService: UploadService) {}

  @Post('single')
  @UseInterceptors(FileInterceptor('file'))
  async uploadSingle(
    @UploadedFile(
      new ParseFilePipe({
        validators: [
          new MaxFileSizeValidator({ maxSize: 5 * 1024 * 1024 }), // 5MB
          new FileTypeValidator({ fileType: /(jpeg|jpg|png|gif)$/i })
        ]
      })
    )
    file: Express.Multer.File,
    @Body() uploadDto: CreateUploadDto
  ) {
    const result = await this.uploadService.uploadFile(file, uploadDto)
    return {
      success: true,
      data: result,
      message: 'File uploaded successfully'
    }
  }

  @Post('multiple')
  @UseInterceptors(FilesInterceptor('files', 10))
  async uploadMultiple(
    @UploadedFiles(
      new ParseFilePipeBuilder()
        .addFileTypeValidator({
          fileType: /(jpeg|jpg|png|gif|pdf|doc|docx)$/i,
        })
        .addMaxSizeValidator({
          maxSize: 10 * 1024 * 1024, // 10MB per file
          maxFileSize: 50 * 1024 * 1024, // 50MB total
        })
        .build({
          errorHttpStatusCode: HttpStatus.UNPROCESSABLE_ENTITY
        })
    )
    files: Express.Multer.File[],
    @Body() uploadDto: CreateUploadDto
  ) {
    const results = await this.uploadService.uploadMultipleFiles(files, uploadDto)
    return {
      success: true,
      data: results,
      message: `${files.length} files uploaded successfully`
    }
  }

  @Post('image')
  @UseInterceptors(FileInterceptor('image'))
  async uploadImage(
    @UploadedFile(
      new ParseFilePipe({
        validators: [
          new MaxFileSizeValidator({ maxSize: 2 * 1024 * 1024 }), // 2MB
          new FileTypeValidator({ fileType: /(jpeg|jpg|png|webp)$/i })
        ]
      })
    )
    image: Express.Multer.File
  ) {
    const result = await this.uploadService.processImage(image)
    return {
      success: true,
      data: result,
      message: 'Image uploaded and processed successfully'
    }
  }
}

// 9. Controller with Swagger Documentation
// src/controllers/products.controller.ts
import {
  Controller,
  Get,
  Post,
  Put,
  Delete,
  Param,
  Body,
  Query,
  HttpStatus
} from '@nestjs/common'
import {
  ApiTags,
  ApiOperation,
  ApiResponse,
  ApiParam,
  ApiQuery,
  ApiBody
} from '@nestjs/swagger'
import { ProductsService } from '../services/products.service'
import { CreateProductDto, UpdateProductDto, ProductQueryDto } from '../dto'
import { Product } from '../entities/product.entity'

@ApiTags('products')
@Controller('products')
export class ProductsController {
  constructor(private readonly productsService: ProductsService) {}

  @Post()
  @ApiOperation({ summary: 'Create a new product' })
  @ApiResponse({ status: 201, description: 'Product created successfully', type: Product })
  @ApiResponse({ status: 400, description: 'Bad request - Invalid input data' })
  @ApiBody({ type: CreateProductDto })
  async create(@Body() createProductDto: CreateProductDto): Promise<Product> {
    return this.productsService.create(createProductDto)
  }

  @Get()
  @ApiOperation({ summary: 'Get all products with pagination and filtering' })
  @ApiResponse({ status: 200, description: 'List of products', type: [Product] })
  @ApiQuery({ name: 'page', required: false, type: Number, description: 'Page number' })
  @ApiQuery({ name: 'limit', required: false, type: Number, description: 'Number of items per page' })
  @ApiQuery({ name: 'search', required: false, type: String, description: 'Search term' })
  @ApiQuery({ name: 'category', required: false, type: String, description: 'Product category' })
  async findAll(@Query() query: ProductQueryDto) {
    return this.productsService.findAll(query)
  }

  @Get(':id')
  @ApiOperation({ summary: 'Get a product by ID' })
  @ApiResponse({ status: 200, description: 'Product found', type: Product })
  @ApiResponse({ status: 404, description: 'Product not found' })
  @ApiParam({ name: 'id', description: 'Product ID' })
  async findOne(@Param('id') id: string): Promise<Product> {
    return this.productsService.findOne(+id)
  }

  @Put(':id')
  @ApiOperation({ summary: 'Update a product by ID' })
  @ApiResponse({ status: 200, description: 'Product updated successfully', type: Product })
  @ApiResponse({ status: 404, description: 'Product not found' })
  @ApiResponse({ status: 400, description: 'Bad request - Invalid input data' })
  @ApiParam({ name: 'id', description: 'Product ID' })
  @ApiBody({ type: UpdateProductDto })
  async update(
    @Param('id') id: string,
    @Body() updateProductDto: UpdateProductDto
  ): Promise<Product> {
    return this.productsService.update(+id, updateProductDto)
  }

  @Delete(':id')
  @ApiOperation({ summary: 'Delete a product by ID' })
  @ApiResponse({ status: 204, description: 'Product deleted successfully' })
  @ApiResponse({ status: 404, description: 'Product not found' })
  @ApiParam({ name: 'id', description: 'Product ID' })
  @HttpCode(HttpStatus.NO_CONTENT)
  async remove(@Param('id') id: string): Promise<void> {
    return this.productsService.remove(+id)
  }
}

// NestJS Authentication and Testing Examples

// 1. JWT Authentication Module
// src/auth/auth.module.ts
import { Module } from '@nestjs/common'
import { JwtModule } from '@nestjs/jwt'
import { PassportModule } from '@nestjs/passport'
import { ConfigModule, ConfigService } from '@nestjs/config'
import { AuthService } from './auth.service'
import { AuthController } from './auth.controller'
import { JwtStrategy } from './strategies/jwt.strategy'
import { LocalStrategy } from './strategies/local.strategy'
import { UsersModule } from '../users/users.module'

@Module({
  imports: [
    UsersModule,
    PassportModule,
    JwtModule.registerAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        secret: configService.get<string>('JWT_SECRET'),
        signOptions: {
          expiresIn: configService.get<string>('JWT_EXPIRES_IN', '1h')
        }
      }),
      inject: [ConfigService]
    })
  ],
  controllers: [AuthController],
  providers: [AuthService, JwtStrategy, LocalStrategy],
  exports: [AuthService]
})
export class AuthModule {}

// src/auth/auth.service.ts
import { Injectable, UnauthorizedException, BadRequestException } from '@nestjs/common'
import { JwtService } from '@nestjs/jwt'
import { UsersService } from '../users/users.service'
import { CreateUserDto, LoginDto } from '../dto'
import * as bcrypt from 'bcrypt'
import { User } from '../entities/user.entity'

@Injectable()
export class AuthService {
  constructor(
    private usersService: UsersService,
    private jwtService: JwtService
  ) {}

  async validateUser(email: string, password: string): Promise<User | null> {
    const user = await this.usersService.findByEmail(email)
    if (!user) {
      throw new UnauthorizedException('Invalid credentials')
    }

    const isPasswordValid = await bcrypt.compare(password, user.password)
    if (!isPasswordValid) {
      throw new UnauthorizedException('Invalid credentials')
    }

    return user
  }

  async login(loginDto: LoginDto) {
    const { email, password } = loginDto
    const user = await this.validateUser(email, password)

    if (!user.isActive) {
      throw new UnauthorizedException('Account is deactivated')
    }

    const payload = {
      sub: user.id,
      email: user.email,
      role: user.role,
      name: user.fullName
    }

    const access_token = this.jwtService.sign(payload)

    // Update last login
    await this.usersService.updateLastLogin(user.id)

    return {
      access_token,
      user: {
        id: user.id,
        email: user.email,
        fullName: user.fullName,
        role: user.role
      }
    }
  }

  async register(createUserDto: CreateUserDto) {
    // Check if user already exists
    const existingUser = await this.usersService.findByEmail(createUserDto.email)
    if (existingUser) {
      throw new BadRequestException('Email already registered')
    }

    // Hash password
    const salt = await bcrypt.genSalt(10)
    const hashedPassword = await bcrypt.hash(createUserDto.password, salt)

    // Create user
    const user = await this.usersService.create({
      ...createUserDto,
      password: hashedPassword
    })

    // Generate JWT token
    const payload = {
      sub: user.id,
      email: user.email,
      role: user.role,
      name: user.fullName
    }

    const access_token = this.jwtService.sign(payload)

    return {
      access_token,
      user: {
        id: user.id,
        email: user.email,
        fullName: user.fullName,
        role: user.role
      }
    }
  }

  async refreshToken(user: any) {
    const payload = {
      sub: user.id,
      email: user.email,
      role: user.role,
      name: user.name
    }

    const access_token = this.jwtService.sign(payload)

    return {
      access_token
    }
  }

  async changePassword(userId: number, currentPassword: string, newPassword: string) {
    const user = await this.usersService.findOne(userId)
    if (!user) {
      throw new UnauthorizedException('User not found')
    }

    const isCurrentPasswordValid = await bcrypt.compare(currentPassword, user.password)
    if (!isCurrentPasswordValid) {
      throw new UnauthorizedException('Current password is incorrect')
    }

    const salt = await bcrypt.genSalt(10)
    const hashedNewPassword = await bcrypt.hash(newPassword, salt)

    await this.usersService.update(userId, { password: hashedNewPassword })

    return { message: 'Password changed successfully' }
  }
}

// src/auth/strategies/jwt.strategy.ts
import { Injectable } from '@nestjs/common'
import { PassportStrategy } from '@nestjs/passport'
import { ExtractJwt, Strategy } from 'passport-jwt'
import { ConfigService } from '@nestjs/config'

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(private configService: ConfigService) {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: configService.get<string>('JWT_SECRET'),
    })
  }

  async validate(payload: any) {
    return {
      id: payload.sub,
      email: payload.email,
      role: payload.role,
      name: payload.name
    }
  }
}

// src/auth/strategies/local.strategy.ts
import { Injectable } from '@nestjs/common'
import { PassportStrategy } from '@nestjs/passport'
import { Strategy } from 'passport-local'
import { AuthService } from '../auth.service'

@Injectable()
export class LocalStrategy extends PassportStrategy(Strategy) {
  constructor(private authService: AuthService) {
    super({
      usernameField: 'email'
    })
  }

  async validate(email: string, password: string): Promise<any> {
    return await this.authService.validateUser(email, password)
  }
}

// 2. Authentication Guards
// src/guards/jwt-auth.guard.ts
import { Injectable } from '@nestjs/common'
import { AuthGuard } from '@nestjs/passport'

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {}

// src/guards/roles.guard.ts
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common'
import { Reflector } from '@nestjs/core'
import { ROLES_KEY } from '../decorators/roles.decorator'
import { UserRole } from '../enums/user-role.enum'

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const requiredRoles = this.reflector.getAllAndOverride<UserRole[]>(ROLES_KEY, [
      context.getHandler(),
      context.getClass(),
    ])

    if (!requiredRoles) {
      return true
    }

    const { user } = context.switchToHttp().getRequest()
    return requiredRoles.some((role) => user.role === role)
  }
}

// src/guards/api-key.guard.ts
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common'
import { ConfigService } from '@nestjs/config'

@Injectable()
export class ApiKeyGuard implements CanActivate {
  constructor(private configService: ConfigService) {}

  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest()
    const apiKey = request.headers['x-api-key'] as string

    const validApiKeys = this.configService.get<string>('API_KEYS')?.split(',') || []

    return validApiKeys.includes(apiKey)
  }
}

// src/guards/throttler.guard.ts
import { Injectable, CanActivate, ExecutionContext, HttpException, HttpStatus } from '@nestjs/common'
import { Reflector } from '@nestjs/core'
import { Request } from 'express'

interface RateLimit {
  windowMs: number
  max: number
}

@Injectable()
export class ThrottlerGuard implements CanActivate {
  private requests = new Map<string, { count: number; resetTime: number }>()

  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest<Request>()
    const rateLimit = this.reflector.get<RateLimit>('throttle', context.getHandler()) || {
      windowMs: 60000, // 1 minute
      max: 100 // 100 requests per minute
    }

    const key = this.getRequestKey(request)
    const now = Date.now()
    const record = this.requests.get(key)

    if (!record || now > record.resetTime) {
      this.requests.set(key, { count: 1, resetTime: now + rateLimit.windowMs })
      return true
    }

    if (record.count >= rateLimit.max) {
      throw new HttpException('Too Many Requests', HttpStatus.TOO_MANY_REQUESTS)
    }

    record.count++
    return true
  }

  private getRequestKey(request: Request): string {
    const ip = request.ip || request.headers['x-forwarded-for'] || request.connection.remoteAddress
    return `${ip}:${request.path}`
  }
}

// 3. Custom Decorators
// src/decorators/roles.decorator.ts
import { SetMetadata } from '@nestjs/common'
import { UserRole } from '../enums/user-role.enum'

export const ROLES_KEY = 'roles'
export const Roles = (...roles: UserRole[]) => SetMetadata(ROLES_KEY, roles)

// src/decorators/throttle.decorator.ts
import { SetMetadata } from '@nestjs/common'

export const THROTTLE_KEY = 'throttle'
export const Throttle = (windowMs: number, max: number) =>
  SetMetadata(THROTTLE_KEY, { windowMs, max })

// src/decorators/public.decorator.ts
import { SetMetadata } from '@nestjs/common'

export const IS_PUBLIC_KEY = 'isPublic'
export const Public = () => SetMetadata(IS_PUBLIC_KEY, true)

// src/decorators/current-user.decorator.ts
import { createParamDecorator, ExecutionContext } from '@nestjs/common'

export const CurrentUser = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest()
    return request.user
  },
)

// 4. Authentication Controller
// src/auth/auth.controller.ts
import {
  Controller,
  Post,
  UseGuards,
  Request,
  Body,
  HttpCode,
  HttpStatus,
  Get
} from '@nestjs/common'
import { AuthService } from './auth.service'
import { LocalAuthGuard } from './guards/local-auth.guard'
import { JwtAuthGuard } from './guards/jwt-auth.guard'
import { CreateUserDto, LoginDto } from '../dto'
import { CurrentUser } from '../decorators/current-user.decorator'
import { Throttle } from '../decorators/throttle.decorator'

@Controller('auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}

  @Post('login')
  @UseGuards(LocalAuthGuard)
  @Throttle(60000, 5) // 5 requests per minute
  @HttpCode(HttpStatus.OK)
  async login(@Request() req, @Body() loginDto: LoginDto) {
    return this.authService.login(loginDto)
  }

  @Post('register')
  @Throttle(300000, 3) // 3 requests per 5 minutes
  async register(@Body() createUserDto: CreateUserDto) {
    return this.authService.register(createUserDto)
  }

  @Post('refresh')
  @UseGuards(JwtAuthGuard)
  async refresh(@CurrentUser() user: any) {
    return this.authService.refreshToken(user)
  }

  @Post('change-password')
  @UseGuards(JwtAuthGuard)
  @Throttle(300000, 3) // 3 requests per 5 minutes
  async changePassword(
    @CurrentUser() user: any,
    @Body() body: { currentPassword: string; newPassword: string }
  ) {
    return this.authService.changePassword(user.id, body.currentPassword, body.newPassword)
  }

  @Get('profile')
  @UseGuards(JwtAuthGuard)
  async getProfile(@CurrentUser() user: any) {
    return {
      success: true,
      data: user
    }
  }
}

// 5. Unit Testing
// src/auth/auth.service.spec.ts
import { Test, TestingModule } from '@nestjs/testing'
import { AuthService } from './auth.service'
import { UsersService } from '../users/users.service'
import { JwtService } from '@nestjs/jwt'
import { UnauthorizedException, BadRequestException } from '@nestjs/common'
import { CreateUserDto, LoginDto } from '../dto'
import { User } from '../entities/user.entity'
import * as bcrypt from 'bcrypt'

jest.mock('bcrypt')

describe('AuthService', () => {
  let service: AuthService
  let usersService: UsersService
  let jwtService: JwtService

  const mockUser: User = {
    id: 1,
    email: '[email protected]',
    fullName: 'Test User',
    password: 'hashedPassword',
    role: 'user',
    isActive: true,
    createdAt: new Date(),
    updatedAt: new Date()
  }

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        AuthService,
        {
          provide: UsersService,
          useValue: {
            findByEmail: jest.fn(),
            create: jest.fn(),
            findOne: jest.fn(),
            updateLastLogin: jest.fn(),
            update: jest.fn()
          }
        },
        {
          provide: JwtService,
          useValue: {
            sign: jest.fn()
          }
        }
      ]
    }).compile()

    service = module.get<AuthService>(AuthService)
    usersService = module.get<UsersService>(UsersService)
    jwtService = module.get<JwtService>(JwtService)

    (bcrypt.compare as jest.Mock).mockResolvedValue(true)
    (bcrypt.hash as jest.Mock).mockResolvedValue('hashedPassword')
    (bcrypt.genSalt as jest.Mock).mockResolvedValue('salt')
  })

  describe('validateUser', () => {
    it('should return user when credentials are valid', async () => {
      usersService.findByEmail.mockResolvedValue(mockUser)

      const result = await service.validateUser('[email protected]', 'password')

      expect(result).toEqual(mockUser)
      expect(usersService.findByEmail).toHaveBeenCalledWith('[email protected]')
      expect(bcrypt.compare).toHaveBeenCalledWith('password', 'hashedPassword')
    })

    it('should throw UnauthorizedException when user does not exist', async () => {
      usersService.findByEmail.mockResolvedValue(null)

      await expect(service.validateUser('[email protected]', 'password'))
        .rejects.toThrow(UnauthorizedException)
    })

    it('should throw UnauthorizedException when password is invalid', async () => {
      usersService.findByEmail.mockResolvedValue(mockUser)
      ;(bcrypt.compare as jest.Mock).mockResolvedValue(false)

      await expect(service.validateUser('[email protected]', 'wrongpassword'))
        .rejects.toThrow(UnauthorizedException)
    })
  })

  describe('login', () => {
    it('should return access token and user when credentials are valid', async () => {
      const loginDto: LoginDto = { email: '[email protected]', password: 'password' }
      const expectedPayload = { sub: 1, email: '[email protected]', role: 'user', name: 'Test User' }

      usersService.findByEmail.mockResolvedValue(mockUser)
      jwtService.sign.mockReturnValue('jwt-token')

      const result = await service.login(loginDto)

      expect(result).toEqual({
        access_token: 'jwt-token',
        user: {
          id: 1,
          email: '[email protected]',
          fullName: 'Test User',
          role: 'user'
        }
      })
      expect(jwtService.sign).toHaveBeenCalledWith(expectedPayload)
    })

    it('should throw UnauthorizedException when account is deactivated', async () => {
      const deactivatedUser = { ...mockUser, isActive: false }
      const loginDto: LoginDto = { email: '[email protected]', password: 'password' }

      usersService.findByEmail.mockResolvedValue(deactivatedUser)

      await expect(service.login(loginDto))
        .rejects.toThrow(UnauthorizedException)
    })
  })

  describe('register', () => {
    it('should return access token and user when registration is successful', async () => {
      const createUserDto: CreateUserDto = {
        email: '[email protected]',
        password: 'password123',
        fullName: 'New User'
      }

      usersService.findByEmail.mockResolvedValue(null)
      usersService.create.mockResolvedValue({ id: 2, ...createUserDto })
      jwtService.sign.mockReturnValue('new-jwt-token')

      const result = await service.register(createUserDto)

      expect(result).toEqual({
        access_token: 'new-jwt-token',
        user: {
          id: 2,
          email: '[email protected]',
          fullName: 'New User',
          role: 'user'
        }
      })
    })

    it('should throw BadRequestException when email already exists', async () => {
      const createUserDto: CreateUserDto = {
        email: '[email protected]',
        password: 'password123',
        fullName: 'Existing User'
      }

      usersService.findByEmail.mockResolvedValue(mockUser)

      await expect(service.register(createUserDto))
        .rejects.toThrow(BadRequestException)
    })
  })
})

// 6. E2E Testing
// test/auth.e2e-spec.ts
import { Test, TestingModule } from '@nestjs/testing'
import { INestApplication } from '@nestjs/common'
import * as request from 'supertest'
import { AppModule } from '../src/app.module'
import { getRepositoryToken } from '@nestjs/typeorm'
import { Repository } from 'typeorm'
import { User } from '../src/users/entities/user.entity'

describe('Authentication (e2e)', () => {
  let app: INestApplication
  let userRepository: Repository<User>

  beforeEach(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [AppModule],
    }).compile()

    app = moduleFixture.createNestApplication()
    userRepository = moduleFixture.get<Repository<User>>(getRepositoryToken(User))

    await app.init()
  })

  afterEach(async () => {
    await userRepository.clear()
    await app.close()
  })

  describe('/auth/register', () => {
    it('should register a new user successfully', () => {
      const createUserDto = {
        email: '[email protected]',
        password: 'password123',
        fullName: 'Test User'
      }

      return request(app.getHttpServer())
        .post('/auth/register')
        .send(createUserDto)
        .expect(201)
        .expect((res) => {
          expect(res.body.access_token).toBeDefined()
          expect(res.body.user.email).toBe(createUserDto.email)
          expect(res.body.user.fullName).toBe(createUserDto.fullName)
        })
    })

    it('should return 400 when email already exists', () => {
      const createUserDto = {
        email: '[email protected]',
        password: 'password123',
        fullName: 'Duplicate User'
      }

      // Create first user
      request(app.getHttpServer())
        .post('/auth/register')
        .send(createUserDto)
        .expect(201)

      // Try to create second user with same email
      return request(app.getHttpServer())
        .post('/auth/register')
        .send(createUserDto)
        .expect(400)
    })
  })

  describe('/auth/login', () => {
    beforeEach(async () => {
      // Create a user for login testing
      const createUserDto = {
        email: '[email protected]',
        password: 'password123',
        fullName: 'Login Test User'
      }

      await request(app.getHttpServer())
        .post('/auth/register')
        .send(createUserDto)
        .expect(201)
    })

    it('should login successfully with valid credentials', () => {
      const loginDto = {
        email: '[email protected]',
        password: 'password123'
      }

      return request(app.getHttpServer())
        .post('/auth/login')
        .send(loginDto)
        .expect(200)
        .expect((res) => {
          expect(res.body.access_token).toBeDefined()
          expect(res.body.user.email).toBe(loginDto.email)
        })
    })

    it('should return 401 with invalid credentials', () => {
      const loginDto = {
        email: '[email protected]',
        password: 'wrongpassword'
      }

      return request(app.getHttpServer())
        .post('/auth/login')
        .send(loginDto)
        .expect(401)
    })
  })

  describe('/auth/profile', () => {
    let accessToken: string

    beforeEach(async () => {
      // Register and login to get access token
      const createUserDto = {
        email: '[email protected]',
        password: 'password123',
        fullName: 'Profile Test User'
      }

      const registerResponse = await request(app.getHttpServer())
        .post('/auth/register')
        .send(createUserDto)

      accessToken = registerResponse.body.access_token
    })

    it('should return user profile with valid token', () => {
      return request(app.getHttpServer())
        .get('/auth/profile')
        .set('Authorization', `Bearer ${accessToken}`)
        .expect(200)
        .expect((res) => {
          expect(res.body.success).toBe(true)
          expect(res.body.data.email).toBe('[email protected]')
        })
    })

    it('should return 401 without token', () => {
      return request(app.getHttpServer())
        .get('/auth/profile')
        .expect(401)
    })

    it('should return 401 with invalid token', () => {
      return request(app.getHttpServer())
        .get('/auth/profile')
        .set('Authorization', 'Bearer invalid-token')
        .expect(401)
    })
  })
})

// 7. Integration Testing with Test Database
// test/auth.integration.spec.ts
import { Test, TestingModule } from '@nestjs/testing'
import { INestApplication } from '@nestjs/common'
import * as request from 'supertest'
import { AppModule } from '../src/app.module'
import { TypeOrmModule } from '@nestjs/typeorm'
import { User } from '../src/users/entities/user.entity'
import { getRepositoryToken } from '@nestjs/typeorm'

describe('Authentication Integration', () => {
  let app: INestApplication
  let userRepository: Repository<User>

  beforeAll(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [
        AppModule,
        TypeOrmModule.forRoot({
          type: 'sqlite',
          database: ':memory:',
          entities: [User],
          synchronize: true,
          logging: false
        })
      ]
    }).compile()

    app = moduleFixture.createNestApplication()
    userRepository = moduleFixture.get<Repository<User>>(getRepositoryToken(User))

    await app.init()
  })

  afterAll(async () => {
    await app.close()
  })

  describe('Complete Authentication Flow', () => {
    it('should handle complete user registration and login flow', async () => {
      const userDto = {
        email: '[email protected]',
        password: 'StrongPassword123!',
        fullName: 'Integration Test User'
      }

      // Step 1: Register user
      const registerResponse = await request(app.getHttpServer())
        .post('/auth/register')
        .send(userDto)
        .expect(201)

      const { access_token, user } = registerResponse.body

      // Step 2: Verify registration response
      expect(access_token).toBeDefined()
      expect(user.email).toBe(userDto.email)
      expect(user.fullName).toBe(userDto.fullName)

      // Step 3: Login with registered credentials
      const loginResponse = await request(app.getHttpServer())
        .post('/auth/login')
        .send({
          email: userDto.email,
          password: userDto.password
        })
        .expect(200)

      // Step 4: Verify login response
      expect(loginResponse.body.access_token).toBeDefined()
      expect(loginResponse.body.user.email).toBe(userDto.email)

      // Step 5: Access protected route
      const profileResponse = await request(app.getHttpServer())
        .get('/auth/profile')
        .set('Authorization', `Bearer ${access_token}`)
        .expect(200)

      expect(profileResponse.body.data.email).toBe(userDto.email)

      // Step 6: Verify user exists in database
      const dbUser = await userRepository.findOne({
        where: { email: userDto.email }
      })

      expect(dbUser).toBeDefined()
      expect(dbUser.fullName).toBe(userDto.fullName)
      expect(dbUser.password).not.toBe(userDto.password) // Password should be hashed
    })

    it('should handle password change', async () => {
      // Register user
      const userDto = {
        email: '[email protected]',
        password: 'OriginalPassword123!',
        fullName: 'Password Test User'
      }

      const registerResponse = await request(app.getHttpServer())
        .post('/auth/register')
        .send(userDto)
        .expect(201)

      const { access_token } = registerResponse.body

      // Change password
      const changePasswordResponse = await request(app.getHttpServer())
        .post('/auth/change-password')
        .set('Authorization', `Bearer ${access_token}`)
        .send({
          currentPassword: 'OriginalPassword123!',
          newPassword: 'NewPassword456!'
        })
        .expect(200)

      // Try login with old password (should fail)
      await request(app.getHttpServer())
        .post('/auth/login')
        .send({
          email: userDto.email,
          password: 'OriginalPassword123!'
        })
        .expect(401)

      // Try login with new password (should succeed)
      const loginResponse = await request(app.getHttpServer())
        .post('/auth/login')
        .send({
          email: userDto.email,
          password: 'NewPassword456!'
        })
        .expect(200)

      expect(loginResponse.body.access_token).toBeDefined()
    })
  })
})

// 8. Mock Testing with Jest Mocks
// src/auth/auth.service.mock.spec.ts
import { Test, TestingModule } from '@nestjs/testing'
import { AuthService } from './auth.service'
import { UsersService } from '../users/users.service'
import { JwtService } from '@nestjs/jwt'

describe('AuthService (Mocked)', () => {
  let service: AuthService
  let mockUsersService: Partial<UsersService>
  let mockJwtService: Partial<JwtService>

  beforeEach(async () => {
    mockUsersService = {
      findByEmail: jest.fn(),
      create: jest.fn(),
      findOne: jest.fn(),
      updateLastLogin: jest.fn(),
      update: jest.fn()
    }

    mockJwtService = {
      sign: jest.fn()
    }

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        AuthService,
        {
          provide: UsersService,
          useValue: mockUsersService
        },
        {
          provide: JwtService,
          useValue: mockJwtService
        }
      ]
    }).compile()

    service = module.get<AuthService>(AuthService)
  })

  describe('login', () => {
    it('should handle successful login with mocked dependencies', async () => {
      const mockUser = {
        id: 1,
        email: '[email protected]',
        password: 'hashedPassword',
        isActive: true,
        role: 'user'
      }

      mockUsersService.findByEmail!.mockResolvedValue(mockUser)
      mockJwtService.sign!.mockReturnValue('mock-jwt-token')

      const result = await service.login({
        email: '[email protected]',
        password: 'password'
      })

      expect(mockUsersService.findByEmail).toHaveBeenCalledWith('[email protected]')
      expect(mockJwtService.sign).toHaveBeenCalledWith({
        sub: 1,
        email: '[email protected]',
        role: 'user'
      })
      expect(result).toEqual({
        access_token: 'mock-jwt-token',
        user: {
          id: 1,
          email: '[email protected]',
          fullName: mockUser.fullName,
          role: 'user'
        }
      })
    })
  })
})