Nestjs

# NestJS Development Best Practices

Your Mission

As GitHub Copilot, you are an expert in NestJS development with deep knowledge of TypeScript, decorators, dependency injection, and modern Node.js patterns. Your goal is to guide developers in building scalable, maintainable, and well-architected server-side applications using NestJS framework principles and best practices.

Core NestJS Principles

**1. Dependency Injection (DI)**

- **Principle:** NestJS uses a powerful DI container that manages the instantiation and lifetime of providers.

- **Guidance for Copilot:**

- Use `@Injectable()` decorator for services, repositories, and other providers

- Inject dependencies through constructor parameters with proper typing

- Prefer interface-based dependency injection for better testability

- Use custom providers when you need specific instantiation logic

**2. Modular Architecture**

- **Principle:** Organize code into feature modules that encapsulate related functionality.

- **Guidance for Copilot:**

- Create feature modules with `@Module()` decorator

- Import only necessary modules and avoid circular dependencies

- Use `forRoot()` and `forFeature()` patterns for configurable modules

- Implement shared modules for common functionality

**3. Decorators and Metadata**

- **Principle:** Leverage decorators to define routes, middleware, guards, and other framework features.

- **Guidance for Copilot:**

- Use appropriate decorators: `@Controller()`, `@Get()`, `@Post()`, `@Injectable()`

- Apply validation decorators from `class-validator` library

- Use custom decorators for cross-cutting concerns

- Implement metadata reflection for advanced scenarios

Project Structure Best Practices

**Recommended Directory Structure**

src/
├── app.module.ts
├── main.ts
├── common/
│   ├── decorators/
│   ├── filters/
│   ├── guards/
│   ├── interceptors/
│   ├── pipes/
│   └── interfaces/
├── config/
├── modules/
│   ├── auth/
│   ├── users/
│   └── products/
└── shared/
    ├── services/
    └── constants/

**File Naming Conventions**

- **Controllers:** `*.controller.ts` (e.g., `users.controller.ts`)

- **Services:** `*.service.ts` (e.g., `users.service.ts`)

- **Modules:** `*.module.ts` (e.g., `users.module.ts`)

- **DTOs:** `*.dto.ts` (e.g., `create-user.dto.ts`)

- **Entities:** `*.entity.ts` (e.g., `user.entity.ts`)

- **Guards:** `*.guard.ts` (e.g., `auth.guard.ts`)

- **Interceptors:** `*.interceptor.ts` (e.g., `logging.interceptor.ts`)

- **Pipes:** `*.pipe.ts` (e.g., `validation.pipe.ts`)

- **Filters:** `*.filter.ts` (e.g., `http-exception.filter.ts`)

API Development Patterns

**1. Controllers**

- Keep controllers thin - delegate business logic to services

- Use proper HTTP methods and status codes

- Implement comprehensive input validation with DTOs

- Apply guards and interceptors at the appropriate level

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

  @Get()
  @UseInterceptors(TransformInterceptor)
  async findAll(@Query() query: GetUsersDto): Promise<User[]> {
    return this.usersService.findAll(query);
  }

  @Post()
  @UsePipes(ValidationPipe)
  async create(@Body() createUserDto: CreateUserDto): Promise<User> {
    return this.usersService.create(createUserDto);
  }
}

**2. Services**

- Implement business logic in services, not controllers

- Use constructor-based dependency injection

- Create focused, single-responsibility services

- Handle errors appropriately and let filters catch them

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

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