emersxw.me
Back to blog
•
8 min read
NestJS: A Comprehensive Look at Its Strengths and Weaknesses

What is NestJS?

NestJS is a progressive Node.js framework designed for building efficient, reliable, and scalable server-side applications. It uses modern JavaScript, is built with TypeScript (but still enables developers to code in pure JavaScript), and combines elements of OOP (Object Oriented Programming), FP (Functional Programming), and FRP (Functional Reactive Programming).

Key Features of NestJS

  • Modular Architecture: NestJS encourages a modular architecture, allowing developers to organize their code into modules. This makes it easier to manage and scale applications.
  • Dependency Injection: Inspired by Angular, NestJS uses dependency injection to manage dependencies, making the code more testable and maintainable.
  • TypeScript Support: Built with TypeScript, NestJS provides strong typing, which helps catch errors at compile time and improves code quality.
  • Built-in Support for Microservices: NestJS offers built-in support for microservices, making it a great choice for building distributed systems.
  • Extensive Documentation: NestJS has comprehensive documentation, making it easier for developers to get started and find solutions to common problems.

Code Example: Basic NestJS Application

Here’s a simple example of a NestJS application with a basic controller and service:

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

// 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 World!';
  }
}

Dependency Injection in NestJS

Dependency injection is a core feature of NestJS, allowing for better separation of concerns and easier testing. It enables you to inject dependencies into your classes rather than creating them manually.

Example: Dependency Injection

// cats.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class CatsService {
  findAll(): string {
    return 'This action returns all cats';
  }
}

// cats.controller.ts
import { Controller, Get } from '@nestjs/common';
import { CatsService } from './cats.service';

@Controller('cats')
export class CatsController {
  constructor(private readonly catsService: CatsService) {}

  @Get()
  findAll(): string {
    return this.catsService.findAll();
  }
}

In this example, CatsService is injected into CatsController, allowing the controller to use the service’s methods without having to instantiate it directly.

Opinionated Structure

NestJS is considered opinionated because it enforces a specific structure and design pattern, similar to Angular. This includes the use of modules, controllers, services, and decorators. While this can be beneficial for maintaining consistency and scalability, it may not suit developers who prefer more flexibility.

Example: DTOs (Data Transfer Objects)

DTOs are used in NestJS to define the shape of data being transferred between layers. They help ensure data integrity and validation.

// create-cat.dto.ts
export class CreateCatDto {
  name: string;
  age: number;
  breed: string;
}

// cats.controller.ts
import { Body, Controller, Post } from '@nestjs/common';
import { CreateCatDto } from './create-cat.dto';

@Controller('cats')
export class CatsController {
  @Post()
  create(@Body() createCatDto: CreateCatDto) {
    return `This action adds a new cat: ${createCatDto.name}`;
  }
}

Swagger Integration for API Documentation

NestJS provides seamless integration with Swagger to automatically generate API documentation. This is achieved using decorators to define API endpoints and their parameters.

Example: Swagger Integration

// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';

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

  const config = new DocumentBuilder()
    .setTitle('Cats example')
    .setDescription('The cats API description')
    .setVersion('1.0')
    .addTag('cats')
    .build();
  const document = SwaggerModule.createDocument(app, config);
  SwaggerModule.setup('api', app, document);

  await app.listen(3000);
}
bootstrap();

In this example, Swagger is set up to generate documentation for the Cats API, providing a user-friendly interface to explore and test the API endpoints.

Common Mistakes with NestJS

While NestJS offers many powerful features, developers can sometimes make mistakes that lead to issues in their applications. Here are some common mistakes and how to avoid them:

1. Ignoring Dependency Injection

Mistake: Manually creating instances of services or controllers instead of using NestJS’s dependency injection system.

Solution: Always use dependency injection to manage your services and controllers. This ensures that your code is testable and maintainable.

// Incorrect
const catsService = new CatsService();

// Correct
@Controller('cats')
export class CatsController {
  constructor(private readonly catsService: CatsService) {}
}

2. Overusing Global Modules

Mistake: Making too many modules global, which can lead to tight coupling and reduced modularity.

Solution: Use global modules sparingly. Only make a module global if its services are needed across the entire application.

3. Not Using DTOs for Validation

Mistake: Skipping the use of DTOs for data validation, leading to potential security and data integrity issues.

Solution: Always use DTOs with validation decorators to ensure that incoming data is properly validated.

import { IsString, IsInt } from 'class-validator';

export class CreateCatDto {
  @IsString()
  name: string;

  @IsInt()
  age: number;

  @IsString()
  breed: string;
}

4. Ignoring Middleware and Interceptors

Mistake: Not leveraging middleware and interceptors for cross-cutting concerns like logging, authentication, and error handling.

Solution: Use middleware and interceptors to handle these concerns in a centralized and reusable manner.

Comparing NestJS with Other JavaScript Frameworks

NestJS vs. Express

Express is one of the most popular Node.js frameworks, known for its simplicity and minimalism. While Express provides a lightweight foundation for building web applications, NestJS offers a more structured and opinionated approach.

  • Structure: NestJS provides a well-defined structure, which can be beneficial for large applications. Express, on the other hand, offers more flexibility but requires developers to define their own architecture.

Express Example:

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello World!');
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});
  • TypeScript: NestJS is built with TypeScript, providing strong typing and better tooling support. Express can be used with TypeScript, but it requires additional setup.

NestJS vs. Koa

Koa is a lightweight and flexible Node.js framework created by the same team behind Express. It aims to be a smaller, more expressive, and more robust foundation for web applications.

  • Middleware: Koa uses async functions and a more modern approach to middleware, which can lead to cleaner and more readable code. NestJS, while supporting middleware, focuses more on a modular and structured approach.

Koa Example:

const Koa = require('koa');
const app = new Koa();

app.use(async ctx => {
  ctx.body = 'Hello World!';
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

NestJS vs. Hapi

Hapi is a rich framework for building applications and services in Node.js. It is known for its powerful plugin system and configuration-driven approach.

  • Configuration: Hapi uses a configuration-driven approach, which can be beneficial for certain types of applications. NestJS, on the other hand, uses decorators and a more code-driven approach.

Hapi Example:

const Hapi = require('@hapi/hapi');

const init = async () => {
  const server = Hapi.server({
    port: 3000,
    host: 'localhost'
  });

  server.route({
    method: 'GET',
    path: '/',
    handler: (request, h) => {
      return 'Hello World!';
    }
  });

  await server.start();
  console.log('Server running on %s', server.info.uri);
};

init();

Pros and Cons of NestJS

Pros

  • Scalability: NestJS’s modular architecture and built-in support for microservices make it a great choice for building scalable applications.
  • TypeScript: Strong typing and better tooling support improve code quality and developer productivity.
  • Community and Ecosystem: A growing community and a rich ecosystem of plugins and modules provide developers with many resources and tools.

Cons

  • Learning Curve: The use of TypeScript and decorators can be challenging for developers new to these concepts.
  • Opinionated: NestJS’s opinionated structure may not be suitable for developers who prefer more flexibility and control over their application’s architecture.
  • Overhead: The additional features and structure of NestJS can introduce some overhead, which may not be necessary for smaller applications.

Conclusion

NestJS is a powerful and versatile framework that offers a structured and scalable approach to building server-side applications. While it may have a steeper learning curve and be more opinionated than other frameworks, its benefits in terms of scalability, maintainability, and TypeScript support make it a compelling choice for many developers. Whether you’re building a small API or a large microservices architecture, NestJS provides the tools and features needed to succeed.

As with any framework, the choice between NestJS and other JavaScript frameworks depends on your specific needs and preferences. Consider the size and complexity of your project, your team’s familiarity with TypeScript, and your desired level of flexibility when making your decision.