NestJS is a powerful framework for building efficient and scalable server-side applications. Developed with a focus on modern JavaScript and TypeScript, NestJS combines object-oriented programming, functional programming, and reactive programming. In this article, we will learn in-depth about NestJS.

What is NestJS?

NestJS is a progressive Node.js framework for building server-side applications. It uses TypeScript by default, providing strong typing and modern JavaScript features, but it also supports pure JavaScript. NestJS is designed to help developers create highly testable, scalable, and maintainable applications.

Prerequisites for NestJS

To effectively learn and use NestJS, you should have a good understanding of the following:

• JavaScript
• TypeScript (recommended)
• NodeJS
• HTTP and RESTful APIs
• Basics of ExpressJS

History of NestJS

NestJS was created by Kamil Myśliwiec and was first released in December 2017. It quickly gained popularity due to its robust features, TypeScript support, and modular architecture. NestJS has since become a key player in the Node.js ecosystem, offering a structure that accelerates development and improves code maintainability.

How Does NestJS Work?

NestJS works by combining elements from different programmingpattern to create a highly modular and scalable architecture. It uses decorators to define metadata for classes and methods, enabling expressive code. NestJS supports dependency injection, allowing developers to manage dependencies efficiently and create loosely coupled components.

Features of NestJS

• Modular Architecture: Provides a modular structure, promoting reusability and easy maintenance.
• TypeScript by Default: Provides robust type-checking and modern JavaScript features.
• Dependency Injection: Implements a powerful dependency injection system for managing dependencies.
• Middleware Integration: Supports Express and Fastify as underlying HTTP servers, allowing easy middleware integration.
• Decorators: Uses decorators for defining routes, middleware, and other components, making the code clean.
• GraphQL Support: Excellent support for GraphQL through dedicated modules.
• Microservices: Built-in support for building microservices architectures.
• Testing Utilities: Provides tools and utilities for writing unit and integration tests.

Getting Started with NestJS

Step 1: Install the Nest CLI

npm install -g @nestjs/cli

Step 2: Create a New Project

nest new nest-gfg
cd project-name

Folder Structure

NestJS Folder Structure

Dependencies

 "dependencies": {
      "@nestjs/common": "^10.0.0",
      "@nestjs/core": "^10.0.0",
      "@nestjs/platform-express": "^10.0.0",
      "reflect-metadata": "^0.2.0",
      "rxjs": "^7.8.1"
  }

Example: Here is a basic NestJS application

//app.controller.ts

import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

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

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

//app.service.ts

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

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

//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 { }

//main.ts

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
    const app = await NestFactory.create(AppModule);
    await app.listen(3000);
}
bootstrap();

Step 3: Run the Application

To start the application, use the following command:

npm run start

Output

How To Install And Setup First NestJS Application

Advantages of NestJS

• Modularity: Provides organized and modular code, making applications easier to manage and scale.
• TypeScript: Offers all the benefits of TypeScript, including type safety and modern JavaScript features.
• Dependency Injection: Simplifies managing dependencies and promotes loose coupling.
• Extensible: Easily integrates with various libraries and frameworks.
• Community and Ecosystem: Strong community support and a rich ecosystem of modules and tools.

Disadvantages of NestJS

• Learning Curve: The framework’s advanced features and concepts can be challenging for beginners.
• Opinionated Structure: While beneficial for many, the opinionated structure might feel restrictive to some developers.
• TypeScript Requirement: Developers not familiar with TypeScript might need to invest additional time in learning it.