Choosing the Right Framework(2024): Unveiling the Strengths of Nest.js (2024)

Chiran Jeewantha

11 min read

Feb 22, 2024

2.1.1 Routes: The Pathways of Your Application

Think of routes as the pathways in your house. Each route guides the user to a different room or functionality. Here’s a simple example:

// Setting up a route in Express.js
const express = require('express');
const app = express();app.get('/', (req, res) => {
 res.send('Welcome to the living room!');
});
app.get('/kitchen', (req, res) => {
 res.send('Time to cook in the kitchen!');
});
// ...and so on

In this example, going to the root URL ('/') is like entering the living room, while going to '/kitchen' takes you to the kitchen. Simple, right?

2.1.2 Middleware: The Helpers Along the Way

Now, imagine middleware as the helpful hands that assist you along these pathways. They can check if you’re allowed to enter a room, modify something on the way, or even guide you to a different path. Here’s a glimpse:

// Middleware example in Express.js
const checkPermission = (req, res, next) => {
 // Some logic to check if the user has permission
 if (userHasPermission) {
 next(); // Move on to the next step
 } else {
 res.status(403).send('Access denied!');
 }
};app.use(checkPermission); // Applying middleware to all routes
// Now, every route will check permission before allowing access

Express.js keeps it straightforward, making it an excellent choice for smaller projects or when you prefer a hands-on approach to construction.

Now, let’s switch gears to Nest.js — the modular architect’s masterpiece. Nest.js loves organization and believes in dividing your application into small, manageable pieces called modules.

Choosing the Right Framework(2024): Unveiling the Strengths of Nest.js (5)

2.2.1 Modules: The Organized Toolkits

Think of modules as separate toolkits for different parts of your house. Each toolkit (module) has its specific role and functionality. Let’s illustrate:

// Creating a module in Nest.js
import { Module, Controller } from '@nestjs/common';@Module({
 controllers: [LivingRoomController],
})
export class LivingRoomModule {}
@Controller('/')
export class LivingRoomController {
 // Your route handlers go here
}

In this Nest.js example, we’ve created a LivingRoomModule that houses the LivingRoomController. This controller is responsible for handling requests related to the living room. Each module is like a neatly organized toolkit for a specific purpose.

2.2.2 Providers: The Handy Helpers

Nest.js also introduces the concept of providers, which are like your handy helpers. They can be services, repositories, or anything you need to make your application function smoothly.

// Provider example in Nest.js
import { Injectable } from '@nestjs/common';@Injectable()
export class HelperService {
 doSomething() {
 // Your helper service logic
 }
}

Here, HelperService is a provider that can assist your controllers or other providers. Nest.js makes sure everything has its place and purpose.

Building a web application is like driving a car — you want to make sure it stays on the right path and follows the rules. In the world of web development, validations act as guardrails, ensuring that the data flowing through your application is safe and reliable. Nest.js, taking it a step further, introduces Data Transfer Objects (DTOs) to enhance the validation process. Let’s take a ride through how validations and DTOs work in Nest.js and compare it with the approach in Express.js, using simple examples that even a beginner driver — I mean, developer — can understand.

Express.js, like a set of traffic signs, provides a straightforward way to guide and control the data traffic in your application. It offers middleware as a tool to implement validations and keep your data in check.

3.1.1 Middleware: The Traffic Controllers

Middleware in Express.js can be compared to traffic controllers who check every vehicle passing through. They ensure that the data follows the rules you’ve set. Let’s look at a simple example:

// Middleware example for validation in Express.js
const express = require('express');
const app = express();// Middleware to check if the request has a valid API key
const checkApiKey = (req, res, next) => {
 const apiKey = req.headers['api-key'];
 if (apiKey && apiKey === 'my-secret-key') {
 next(); // Move on to the next step if the key is valid
 } else {
 res.status(401).send('Invalid API key');
 }
};
app.use(checkApiKey); // Applying middleware to all routes
// Your routes go here, and they will only be accessible if the API key is valid

In this example, the checkApiKey middleware acts as a guardrail, making sure that requests without a valid API key don't get through. It's like a traffic sign saying, "No entry without the right key!"

Nest.js takes validations to the next level by providing decorators that act as your dedicated traffic control officers. These decorators help define the rules directly in your controllers. Introducing DTOs into Nest.js adds an extra layer of validation before data even reaches your controllers.

3.2.1 Decorators and DTOs: The Dedicated Officers with Precise Instructions

Decorators in Nest.js are like dedicated officers stationed at specific points, ensuring that data adheres to the rules. Let’s see an example with DTOs:

// Validation example with decorators and DTOs in Nest.js
import { Controller, Get, Query } from '@nestjs/common';class GetCarsDto {
 color: string;
}
@Controller('/cars')
export class CarsController {
 @Get()
 getCars(@Query() params: GetCarsDto) {
 // Your logic goes here, and params.color is guaranteed to be a string
 }
}

In this Nest.js example, we introduced the GetCarsDto class, which serves as a DTO, specifying the expected structure of the incoming data. The @Query decorator ensures that the parameters in the request adhere to this structure. It's like a traffic control officer checking not only the type but also the precise details of the vehicles passing through.

Building a web application is like creating a story, and the database is the library where all the information is stored. In the realm of web development, frameworks like Nest.js and Express.js offer unique approaches to connect and interact with databases. Let’s embark on a journey to understand how these frameworks handle databases, with examples that even a library-loving beginner developer can comprehend.

4.1 Express.js: The DIY Library Explorer

Express.js, like a do-it-yourself library explorer, gives developers the freedom to choose how they want to interact with databases. It doesn’t prescribe a specific library or method, allowing you to handpick the tools that best suit your needs.

Middleware in Express.js can be compared to tools in your library explorer kit. You can choose different libraries, like Mongoose or Sequelize, to navigate and interact with your database.

Here’s a simplified example using Mongoose for MongoDB:

// Example using Mongoose with Express.js
const express = require('express');
const mongoose = require('mongoose');
const app = express();mongoose.connect('mongodb://localhost/library', { useNewUrlParser: true, useUnifiedTopology: true });
const BookSchema = new mongoose.Schema({
 title: String,
 author: String,
});
const Book = mongoose.model('Book', BookSchema);
app.get('/books', async (req, res) => {
 const books = await Book.find();
 res.json(books);
});
app.listen(3000, () => {
 console.log('Server is running on port 3000');
});

In this example, we use Mongoose, a popular library for MongoDB, to define a schema for books and fetch all books from the database when someone visits the ‘/books’ endpoint. It’s like exploring the library shelves and listing all the available books.

4.2 Nest.js: The Library Catalog with Decorators

Nest.js, akin to a well-organized library catalog, introduces decorators and a built-in module system to seamlessly integrate databases into your application. It follows a more structured approach, making it a great choice for those who appreciate organization.

Decorators in Nest.js act as the labels on the library shelves, providing clear instructions on how to interact with the database. Let’s see a simple example using TypeORM for a PostgreSQL database:

// Example using TypeORM with Nest.js
import { Module, Controller, Get } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';@Entity()
class Book {
 @PrimaryGeneratedColumn()
 id: number;
 @Column()
 title: string;
 @Column()
 author: string;
}
@Controller('/books')
class BooksController {
 constructor(private readonly bookService: BookService) {}
 @Get()
 async getBooks() {
 return await this.bookService.findAll();
 }
}
@Module({
 imports: [TypeOrmModule.forRoot(), TypeOrmModule.forFeature([Book])],
 controllers: [BooksController],
 providers: [BookService],
})
class BooksModule {}
class BookService {
 async findAll(): Promise<Book[]> {
 return await Book.find();
 }
}

In this Nest.js example, we use TypeORM to create a Book entity, a service to fetch all books, and a controller to handle requests. Decorators like @Entity and @Column provide clear instructions on how to define the database structure. It's like consulting a well-organized library catalog to find and fetch books.

When it comes to building web applications, performance is like the speed of your favorite race car. In the world of web development, frameworks like Nest.js and Express.js are the engines that power your digital race car. Let’s delve into the realm of performance in these frameworks without getting tangled in technical jargon

Choosing the Right Framework(2024): Unveiling the Strengths of Nest.js (6)

5.1 Express.js: The Sprinter

Express.js is like a nimble sprinter. It’s quick, lightweight, and gets the job done in a flash. If your goal is to build a small to medium-sized application, Express.js is your go-to sprinter. Its simplicity and minimalism make it a speedy choice for simpler projects.

Features:
- Forms the backend component of the MEAN stack (MongoDB, ExpressJS, AngularJS, NodeJS).
- Designed for building APIs, web applications, and mobile apps, catering to single-page and multi-page applications.
- Utilizes middleware modules for handling HTTP requests, sessions, and other tasks.
- Easily connects with databases such as MongoDB, Redis, MySQL, etc.
- Employs a sophisticated routing mechanism and offers template engines for dynamic content creation.

Pros:

Enables quick and easy web application development, saving coding time.

Easy to learn, especially for those familiar with JavaScript.

Strong and supportive online community, providing a wealth of resources.

Cons:

Error messages might be challenging to understand for beginners.

May face callback issues, which could complicate asynchronous programming.

More suitable for small to medium-sized projects, lacking optimal scalability for large projects.

- Key Points:

Lightweight and quick to set up.
Ideal for smaller applications and quick development.
Well-suited for microservices architecture.

5.2 Nest.js: The Marathon Runner

Nest.js, on the other hand, is the marathon runner of frameworks. It’s built for endurance, scalability, and handling larger, complex applications. If you’re envisioning a big, long-term project, Nest.js is designed to go the distance. Its modular structure and TypeScript support contribute to a more organized and scalable development process.

Features:
- Leverages TypeScript, blending OOP, FP, and FRP elements.
Platform agnostic, initially using Express but adaptable to various HTTP frameworks.
- Compatible with multiple databases like PostgreSQL, MongoDB, MySQL, Redis, and Apache Cassandra.
- Provides extensive functionalities, APIs, and libraries to streamline development.
- Offers built-in Dependency Injection container for cleaner and readable code.
- Organizes code into modules, promoting modular and reusable chunks.
Facilitates building both Monoliths and Micro-services.
- Easily integrates with technologies like Mongoose, TypeORM, GraphQL, and supports logging, validation, caching, and Web Sockets.

Pros:

Takes advantage of TypeScript, enhancing code reliability and readability.
Active Development:

Maintains an actively developed codebase with detailed documentation.

User-friendly, easy to learn, and comes with a powerful CLI for efficient development.

Cons:
Requires knowledge of TypeScript, which might be a learning curve for some developers.

Relatively smaller user base compared to more established frameworks, leading to less online support.

- Key Points:

Structured and modular for larger applications.
Built-in support for TypeScript enhances code organization.
Suitable for projects that require scalability and maintainability.

5.3 Comparing the Racers:

~ Speed:

Express.js is like a sprinter, quickly handling smaller tasks.
Nest.js is a marathon runner, built for long-term and larger projects.

~ Complexity:

Express.js excels in simplicity, making it great for straightforward projects.
Nest.js shines in handling complexity, providing a more organized structure.

~ Development Approach:

Express.js is ideal for rapid development and smaller tasks.
Nest.js suits projects where long-term scalability and maintainability are key.

~ TypeScript Support:

Express.js primarily uses JavaScript.
Nest.js has built-in support for TypeScript, adding static typing for better code organization.

In the realm of web development, NestJS and ExpressJS emerge as prominent players, each with its unique strengths and considerations.

NestJS stands out for its versatility, leveraging TypeScript and offering a modular structure that simplifies building scalable server-side applications. With an extensive feature set, it seamlessly integrates with various databases and technologies, providing a robust foundation for both monolithic and microservices architectures.

On the other hand, ExpressJS is celebrated for its simplicity and efficiency. As the backend powerhouse of the MEAN stack, it excels in quickly building APIs and web applications. Its straightforward approach and strong community support make it an excellent choice for small to medium-sized projects.

In the end, the choice between NestJS and ExpressJS boils down to the complexity and scale of your project. For those seeking a versatile and structured framework with TypeScript advantages, NestJS shines. Meanwhile, ExpressJS remains a reliable and efficient option, particularly for rapid development and community support. Whether you opt for the structured elegance of NestJS or the straightforward efficiency of ExpressJS, both frameworks offer pathways to successful web development endeavors.

For those looking to dive deeper into the world of NestJS and ExpressJS, I recommend exploring the following resources:

NestJS Documentation: Delve into the official NestJS documentation for comprehensive insights into the framework’s features, functionalities, and best practices.
ExpressJS Documentation: Explore the ExpressJS documentation to gain a deeper understanding of the framework’s capabilities, middleware usage, and efficient routing mechanisms.
TypeScript Documentation: If you’re new to TypeScript, the official TypeScript documentation provides valuable information on the language NestJS is built upon.

Happy coding and exploring!