Nest.js.

A Nest.js application is built from modules, controllers and providers. A module is a class decorated with @Module() that groups related controllers and providers and encapsulates them. A controller handles incoming requests and returns responses. A provider is a class Nest can inject, such as a service, a repository or a factory. Services hold the business logic and are the most common providers.

Smaller pieces bound to a route run around its handler:

• Middleware runs before the route handler.
• Guards decide whether a request should be handled.
• Interceptors add logic around the handler and can transform its result.
• Pipes transform and validate input data.
• Exception filters handle errors and turn them into responses.

Decorators are functions you attach with the @ sign to a class or to its methods, properties and parameters. Each one adds metadata to its target. Nest reads that metadata to build routes and to wire up dependency injection.

Nest uses three main kinds:

• Class decorators say what a class is. @Module() defines a module, @Controller() defines a controller, and @Injectable() makes a class injectable as a provider.
• Method decorators such as @Get() and @Post() map a method to an HTTP route.
• Parameter decorators read the request. @Param() reads a route parameter, @Query() the query string, and @Body() the request body.

@Injectable()        // Makes class injectable
export class UsersService {}

@Controller('users')  // Defines a controller
export class UsersController {
  @Get(':id')          // HTTP GET method
  findOne(@Param('id') id: string, @Query() query: Record<string, string>) {} // Route parameter, query parameters

  @Post()              // HTTP POST method
  create(@Body() body: CreateUserDto) {} // Request body
}

@Module({ controllers: [UsersController], providers: [UsersService] }) // Defines a module
export class UsersModule {}

Nest relies on TypeScript's experimentalDecorators and emitDecoratorMetadata options, which nest new turns on in tsconfig.json.

@Injectable() marks a class as a provider that Nest can create and inject into other classes. @Controller() marks a class as a controller that handles HTTP requests, optionally under a route prefix such as 'users'.

Use @Injectable() for services, repositories and other classes that hold business logic. You list them in a module's providers array. Nest then injects them into the constructors of controllers and other providers in that module.

Use @Controller() for the classes that define your API endpoints. Their methods carry route decorators such as @Get() and @Post(), and you list the class in a module's controllers array.

Controllers can have services injected into them, but services are not controllers. Keep controllers thin. They read the request and hand the business logic and data access to services.

A module is a class decorated with @Module() that groups a related set of controllers and providers. Every application has at least one, the root module, and Nest builds its dependency graph starting from it.

@Module({
  imports: [DatabaseModule],      // Other modules to import
  controllers: [UserController],  // Controllers in this module
  providers: [UserService],       // Services/providers in this module
  exports: [UserService]          // Providers to export for other modules
})
export class UserModule {}

By default, a module encapsulates its providers. Another module can inject only the providers listed in exports, and only after it adds this module to its imports.

Modules give you:

• a small public API for each feature, through exports
• a clear separation of concerns, one module per feature
• reuse of the same module across applications
• lazy loading through LazyModuleLoader, which loads a module only when it is needed

Middleware is a function or class that runs before the route handler. It gets the request and response objects and a next() function. It can read or change the request and the response, end the response early, or call next() to pass control on. If it neither ends the response nor calls next(), the request is left hanging.

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`${req.method} ${req.url}`);
    next();
  }
}

// Apply in module
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('users');
  }
}

A class middleware implements NestMiddleware and its use() function. To apply it, the module implements NestModule and registers it in configure() through the MiddlewareConsumer. forRoutes() takes a path, a controller class, or a route object with a path and an HTTP method. exclude() skips routes.

Nest middleware works like Express middleware by default, so most Express middleware packages work in Nest too.

A Data Transfer Object (DTO) is a class that defines the shape of data sent over the network, such as a request body. Nest recommends classes over TypeScript interfaces. Interfaces are removed at compile time, and pipes need a real class at runtime.

export class CreateUserDto {
  @IsString()
  @IsNotEmpty()
  name: string;
  @IsEmail()
  email: string;
  @IsInt()
  @Min(18)
  age: number;
}

@Post()
createUser(@Body() createUserDto: CreateUserDto) {
  return this.userService.create(createUserDto);
}

The class-validator decorators only describe the rules. They run when ValidationPipe is active, usually registered once with app.useGlobalPipes(new ValidationPipe()). An invalid body then gets a 400 Bad Request response before the handler runs.

DTOs give you type safety in the handler, input validation and a clear data contract. @nestjs/swagger also reads DTO classes to generate API documentation.