Same as Module, view, controller?

Module

A module is a class that organizes your application into cohesive blocks. Every application in NestJS has at least one module, the root module(AppModule). Modules are used to group related components like controller providers and other services.

Key Points:

• Modules help with encapsulation. each module is independent but can export its services to other modules
• NestJS uses metadata (decorators) to define modules with @Module() decorator
• Feature modules can be created to represent specific features of an application (e.g., User Module, AUthModule)

Example:

import { Module } from '@nestjs/common';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';

@Module({
  imports: [], // Other modules can be imported here
  controllers: [UsersController], // Controllers are defined here
  providers: [UsersService], // Services and providers are defined here
  exports: [UsersService], // Services to be shared with other modules
})
export class UsersModule {}

Provider

A Provider is a service, repository, factory, or value that can be injected into other parts of your application via dependency injection. The main idea behind a provider is to encapsulate reusable logic, allowing it to be shared across the application.

• Providers are usually services, but they can be any calls that performs a task or contains logic that can be injected elsewhere.
• Providers are registered in the providers array of a module, and they are instantiated by Nest’s IoC(Inversion of Control) container

import { Injectable } from '@nestjs/common';

@Injectable() // Marks this class as a provider
export class UsersService {
  private readonly users = [];

  findAll() {
    return this.users; // Business logic to fetch users
  }

  addUser(user) {
    this.users.push(user); // Business logic to add a user
  }
}

Controller

A Controller is responsible for handling incoming HTTP requests and returning responses to the client. It contains methods that correspond to the different routes/endpoints of your API. Controllers handle user input, and delegate the logic to the providers (like services).

• A controller is decorated with @Controller and its methods are decorated with HTTP method decorated such as @Get(), @Post(), etc.
• Controllers focus on handling requests, while providers handle the business logic.

import { Controller, Get, Post, Body } from '@nestjs/common';
import { UsersService } from './users.service';

@Controller('users') // Prefixes the route (e.g., /users)
export class UsersController {
  constructor(private readonly usersService: UsersService) {} // Injecting the service

  @Get() // Handles GET requests to /users
  findAll() {
    return this.usersService.findAll();
  }

  @Post() // Handles POST requests to /users
  addUser(@Body() user: any) {
    this.usersService.addUser(user);
  }
}