NestJS

NestJS is a progressive Node.js framework for building efficient, reliable, and scalable server-side applications. It is designed to make the development process straightforward and maintainable, with a modular architecture and built-in support for dependency injection, making it popular for building APIs, microservices, and full-stack applications.

Features

• API Development: NestJS provides a robust set of tools and features for building RESTful APIs. It offers decorators, middleware, routing, and other utilities to simplify the development process and improve code quality.
• Standalone Applications: NestJS applications can be run as standalone servers.
• Modular Architecture: NestJS applications are built using modules, which help organize code into reusable and maintainable components. Modules encapsulate related functionality, such as controllers, services, and providers, making it easier to manage complex applications.
• Dependency Injection: NestJS provides a powerful dependency injection system that allows you to define and inject dependencies into classes, making your code more modular, testable, and scalable.
• Decorators: Decorators in NestJS are used to enhance classes or class members with additional properties or behaviors at runtime. They provide a way to annotate and modify the behavior of your code without changing its logic.
• Middleware: NestJS supports middleware functions that can intercept incoming requests, modify them, or perform additional processing before they reach the route handler. This allows you to add cross-cutting concerns such as logging, authentication, and error handling.
• much more...

Decorators

In NestJS, decorators play a crucial role in defining and configuring various elements of your application, such as modules, controllers, services, and more. Decorators in NestJS are used to enhance classes or class members with additional properties or behaviors at runtime. They essentially provide a way to annotate and modify the behavior of your code without changing its logic.

Here are some key points about decorators in NestJS:

1. Usage: Decorators are applied using the @ symbol followed by the decorator name. For example, @Module, @Controller, @Injectable, etc.

2. Types of Decorators: NestJS provides several built-in decorators that serve different purposes:

   • Module Decorators: Used to define modules in your application (@Module).
   • Controller Decorators: Define controllers that handle incoming requests (@Controller).
   • Injectable Decorators: Define services that will be injected else where (@Injectable).
   • Route Decorators: Define routes within controllers (@Get, @Post, @Put, @Delete, etc.).
   • Documentation Decorators: Define request and response properties for documenten the RestAPI in Swagger (@ApiProperty)
   • Dependency Injection Decorators: Used to inject dependencies into classes (@Inject, @InjectRepository, etc.).
   • Middleware Decorators: Define middleware functions (@Middleware).

3. Custom Decorators: NestJS allows you to create custom decorators to encapsulate common patterns or to extend the framework's capabilities. These can be used to enforce custom validation, logging, authorization checks, and more.

4. Functionality: Each decorator in NestJS typically alters the behavior of the target class or member in a specific way. For instance, @Module decorators define the scope and dependencies of a module, @Controller decorators define request handling routes, and @Injectable decorators mark classes as injectable services.

Overall, decorators in NestJS provide a powerful and expressive way to configure and structure your application, making it easier to build scalable and maintainable server-side applications in TypeScript.

Injectables

In NestJS, injectables are classes that can be injected as dependencies into other classes using the built-in dependency injection system. This allows you to define services, repositories, or other utility classes that can be shared and reused throughout your application.

An injectable should only be once declared inside a module within the providers array. This will make the class available for injection within the module and its children. If you want to use the injectable outside of the module, you can export it from the module by adding it to the exports array.

Here are some key points about injectables in NestJS:

• Usage: To define a class as an injectable, you need to apply the @Injectable() decorator to the class definition. This tells NestJS that the class can be injected as a dependency.
• Dependency Injection: Injectables can be injected into other classes using the @Inject() decorator or constructor injection. This allows you to decouple your code and make it more modular and testable.
• Singleton Scope: By default, injectables in NestJS are singletons, meaning that the same instance of the class is shared across the application. This can help improve performance and reduce memory usage.
• Lifecycle Hooks: Injectables can implement lifecycle hooks such as OnModuleInit and OnModuleDestroy to perform initialization and cleanup tasks when the module is started or stopped.
• Testing: Injectables can be easily mocked or replaced during testing, allowing you to isolate and test individual components of your application.

Example

@Injectable()
export class UserService {
  public async someFunction(): Promise<void> {
   // Implementation
  }
}

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

  @Get()
  public async getUser(): Promise<void> {
    await this.userService.someFunction();
  }
}