Introduction to NestJS: Overview and Features

Introduction to NestJS: Overview and Features

NestJS is a rapidly growing framework for building efficient, scalable Node.js server-side applications. Built with TypeScript and heavily inspired by Angular, it promotes a modular architecture and comes equipped with built-in tooling to help developers write robust, maintainable code. In this article, we’ll explore the key features of NestJS and walk through some example code to get you started.

Why NestJS?

The primary aim of NestJS is to fill the gap that existed in the Node.js ecosystem for a fully-fledged framework that offers a complete collection of essential features and supports TypeScript out of the box. Here are some compelling reasons to consider using NestJS:

• TypeScript First: NestJS is written in TypeScript, ensuring you benefit from its powerful type-checking and modern JavaScript features.
• Modular Architecture: Encourages a modular approach to application design, making it easier to organize and scale.
• Dependency Injection: Built-in dependency injection (DI) eases the management of your application’s dependencies.
• Extensible: Integrates with a wide range of libraries and tooling in the Node.js ecosystem.
• Testing: Supports testing through Jest out of the box.

Let’s dive into some of these features in more detail and see how they can be utilized with code examples.

Setting Up A NestJS Project

First, you need to have Node.js installed. Then, you can quickly create a new NestJS application by using the Nest CLI.

npm i -g @nestjs/cli
nest new my-nest-app

Navigate to your project directory:

cd my-nest-app

Run the application:

npm run start

By default, your application will be running at http://localhost:3000.

Creating Your First Module

In NestJS, a module is a class annotated with a @Module() decorator. Modules are used to organize the application into cohesive blocks of functionality. You can generate a module using the CLI:

nest generate module users

This command will create a new module named UsersModule.

Creating a Controller

Controllers are responsible for handling incoming requests and returning responses to the client. You can generate a controller using the CLI:

nest generate controller users

Let’s define a simple controller to handle user-related requests. Edit users.controller.ts:

import { Controller, Get } from '@nestjs/common';

@Controller('users')
export class UsersController {
  @Get()
  findAll(): string {
    return 'This action returns all users';
  }
}

Creating a Service

Services are used to handle business logic and service-related operations. You can generate a service using the CLI:

nest generate service users

Let’s define a simple service to return user data. Edit users.service.ts:

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

@Injectable()
export class UsersService {
  private readonly users: string[] = ['John', 'Doe', 'Jane'];
  findAll(): string[] {
    return this.users;
  }
}

Integrating Controller and Service

Next, integrate the service into the controller. Update users.controller.ts:

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

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}
  @Get()
  findAll(): string[] {
    return this.usersService.findAll();
  }
}

Make sure to update your users.module.ts to include the controller and service:

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

@Module({
  controllers: [UsersController],
  providers: [UsersService],
})
export class UsersModule {}

Dependency Injection

NestJS’s dependency injection (DI) system is one of its core features. By automatically injecting dependencies into classes and services, NestJS simplifies the app’s structure and enhances its maintainability. In the example above, the UsersService is automatically injected into UsersController via the constructor.

Middleware, Pipes, Guards, and Interceptors

NestJS offers a robust set of features that help manage various aspects of an application:

• Middleware: Functions executed before the route handler.
• Pipes: Transform inputs.
• Guards: Determine if a route’s handler can be executed.
• Interceptors: Add additional logic before and after method execution.

For example, to create middleware, you can use the CLI:

nest generate middleware logger

Then, implement the middleware function:

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log('Request...');
    next();
  }
}

Conclusion

NestJS brings the best of several worlds together: TypeScript, Angular-inspired architecture, and a strong emphasis on modularity and maintainability. Whether you’re building a small app or a large-scale enterprise solution, NestJS provides a solid foundation.

Ready to dive deeper? Check out the official documentation of NestJS for more detailed guides and examples.

Happy coding! 🎉