Unlocking Backend Brilliance: A Journey into NestJS for Creating RESTful API

If you're just starting out on your journey in backend development, you're in for a treat. NestJS is not your average Node.js framework – it's a powerhouse that seamlessly integrates TypeScript, offering a structured approach to crafting robust server-side applications.

In this article, we're embarking on a concise yet hands-on exploration of NestJS. By the time you reach the end, you'll be equipped with the knowledge and confidence to create your very own RESTful APIs. ??

So, buckle up and get ready to unlock the full potential of NestJS! Let's dive in together and pave the way for your future endeavors in backend development. ??

Prerequisites

Before diving into NestJS, make sure you have Node.js and npm (Node Package Manager) installed on your machine. If you haven't already installed them, you can download them from the official Node.js website here. Once you have Node.js and npm set up, you're all set to get started! ??

Project Setup

1. Create a New Directory: First, let's create a dedicated directory for our NestJS project. Open your terminal and navigate to the desired location where you want to create your project.
2. Generate a New NestJS Project: Now, it's time to use the powerful Nest CLI to kickstart our project. Run the following command:

$ npx @nestjs/cli new book-management-api        

After running above command you will be asked to select a package manager of the project, for this project we will be selecting npm

The above command will initiate the creation of a new NestJS project named "book-management-api" in the directory you're currently in.

Navigate into the Project Directory:

Once the command completes successfully, let's navigate into our newly generated project directory. Use the following command:

$ cd book-management-api        

Now, you're inside your NestJS project directory, ready to start building amazing things!

With above simple steps, you've laid the foundation for your NestJS project. Now that we have our NestJS project set up, let's take a tour of the default directory structure. Understanding the layout of the project will help us navigate and organize our code effectively. Below is the folder structure of any nest.js project by default

Let's take bit of our time understanding each of the files and folders of our project

1. node_modules: This directory contains all the dependencies installed for your project. You don't need to modify anything here; it's managed by npm.
2. src: This directory is where most of your project code resides. Let's explore its contents further:app.controller.spec.ts: This is a sample test file for the default controller. It's used for testing purposes and can be safely deleted if not needed.app.controller.ts: This is the default controller file. Controllers are responsible for handling incoming requests and returning responses. You'll define your API endpoints and their corresponding logic here.app.module.ts: This is the main module of your NestJS application. It serves as the entry point for your application, where you can import other modules and configure global middleware.app.service.ts: This is the default service file. Services contain the business logic of your application. They are responsible for interacting with data sources, performing computations, and returning results to controllers.main.ts: This is the entry point of your application. It bootstraps the NestJS application by creating an instance of the AppModule and starting the NestJS server.
3. test: This directory contains test files for your application. By default, there's a sample test file for the default controller.
4. tsconfig.json: This file contains TypeScript compiler options for your project. It defines how TypeScript files should be compiled into JavaScript.
5. nest-cli.json: This file contains configuration options for the Nest CLI. You can customize project settings such as the directory structure, TypeScript compiler options, and more.
6. package.json: This file contains metadata about your project and its dependencies. It also includes scripts for running, testing, and building your application.
7. package-lock.json: This file is automatically generated by npm and is used to lock down the versions of dependencies installed in your project. It ensures consistent dependency versions across different environments.
8. README.md: This file contains information about your project, including how to install and run it. It's often used to provide instructions for developers who are new to the project.

Now that we have our Nest.js project set up and we're familiar with its directory structure, let's dive into how we can use it to create a RESTful API.

But wait... Do you know what exactly REST API is ?

If not do not worry I will explain it for you in brief read the below section

REST API (Representational State Transfer)

REST, or Representational State Transfer, is an architectural style for designing networked applications. It relies on a stateless, client-server communication protocol, typically HTTP, and follows a set of principles for defining how resources are identified and addressed. In a RESTful architecture, resources are represented as URIs (Uniform Resource Identifiers), and interactions with these resources are performed using standard HTTP methods like GET, POST, PUT, DELETE, etc.

If you want to know in more details then I would suggest you going through this blog.

As now all of you are familiar with REST API architecture let's create an API using Nest.js

Creating a REST API with Nest.js:

Now that we have our Nest.js project set up and we're familiar with its directory structure, let's dive into how we can use it to create a RESTful API. Let's build a simple book management API by following below simple steps:

Define Your Data Model:

Before creating endpoints, it's important to define the structure of your data. This could be done using TypeScript interfaces or classes. For example, as we're building a simple book management API, we will have a Book interface with properties like id, title, author, and description.So let's define a simple data model for books. Create a file named book.model.ts in the src directory with the following content:

// src/book.model.ts

export interface Book {
  id: number;
  title: string;
  author: string;
  description: string;
}
        

Implement Services:

Services in Nest.js contain the business logic of your application. They are responsible for interacting with data sources (like databases) and performing any necessary operations.

For our Book Management API, let's create BookService by using Nest CLI

nest generate service books        

This will create a books.service.ts file in the src directory. Write the below lines of code in the file

// src/books/books.service.ts

import { Injectable, NotFoundException } from '@nestjs/common';
import { Book } from '../book.model';

@Injectable()
export class BooksService {
    private books: Book[] = [
        { id: 1, title: 'Book 1', author: 'Author 1', description: 'Description for Book 1' },
        { id: 2, title: 'Book 2', author: 'Author 2', description: 'Description for Book 2' },
        { id: 3, title: 'Book 3', author: 'Author 3', description: 'Description for Book 3' }
    ];
    ;

    async getAllBooks(): Promise<Book[]> {
        return this.books;
    }

    async getBookById(id: number): Promise<Book> {
        const book = this.books.find(book => book.id === id);
        if (!book) {
            throw new NotFoundException('Book not found');
        }
        return book;
    }

    async createBook(bookData: Book): Promise<void> {
        this.books.push({ ...bookData, id: this.generateId() });
    }

    async updateBook(id: number, updatedBookData: Book): Promise<void> {
        const index = this.books.findIndex(book => book.id === id);
        if (index === -1) {
            throw new NotFoundException('Book not found');
        }
        this.books[index] = { ...this.books[index], ...updatedBookData };
    }

    async deleteBook(id: number): Promise<void> {
        const index = this.books.findIndex(book => book.id === id);
        if (index === -1) {
            throw new NotFoundException('Book not found');
        }
        this.books.splice(index, 1);
    }

    private generateId(): number {
        return this.books.length > 0 ? Math.max(...this.books.map(book => book.id)) + 1 : 1;
    }
}        

In above BooksService, we have the following methods:

• getAllBooks(): Retrieves all books from the in-memory data structure and returns them.
• getBookById(id): Retrieves a book by its ID from the in-memory data structure and returns it. If the book is not found, it throws a NotFoundException.
• createBook(bookData): Adds a new book to the in-memory data structure. It generates a unique ID for the new book and assigns it before adding it to the array of books.
• updateBook(id, updatedBookData): Updates an existing book in the in-memory data structure based on its ID. If the book is not found, it throws a NotFoundException.
• deleteBook(id): Deletes a book from the in-memory data structure based on its ID. If the book is not found, it throws a NotFoundException.

These methods handle the business logic for managing books and interact directly with the in-memory JSON structure to perform CRUD operations.

Create a Controller:

As we already know Controllers in Nest.js are responsible for handling incoming HTTP requests and returning responses. You can create a new controller using the Nest CLI command as given below:

nest generate controller <controllerName>         

Inside your controller, define methods to handle different HTTP methods (GET, POST, PUT, DELETE) and map them to specific routes.

Let's create a controller books by using Nest CLI command as shown below

nest generate controller books        

This will create a books.controller.ts file in the src directory. Update it with the following code:

// src/books/books.controller.ts

import { Controller, Get, Post, Put, Delete, Param, Body, NotFoundException } from '@nestjs/common';
import { BooksService } from './books.service';
import { Book } from './book.model';

@Controller('books')
export class BooksController {
  constructor(private readonly booksService: BooksService) {}

  @Get()
  async getAllBooks(): Promise<Book[]> {
    return this.booksService.getAllBooks();
  }

  @Get(':id')
  async getBookById(@Param('id') id: string): Promise<Book> {
    const book = await this.booksService.getBookById(Number(id));
    if (!book) {
      throw new NotFoundException('Book not found');
    }
    return book;
  }

  @Post()
  async createBook(@Body() bookData: Book): Promise<void> {
    await this.booksService.createBook(bookData);
  }

  @Put(':id')
  async updateBook(@Param('id') id: string, @Body() updatedBookData: Book): Promise<void> {
    await this.booksService.updateBook(Number(id), updatedBookData);
  }

  @Delete(':id')
  async deleteBook(@Param('id') id: string): Promise<void> {
    await this.booksService.deleteBook(Number(id));
  }
}

        

In above BooksController, we have the following methods:

• getAllBooks(): Handles GET requests to fetch all books.
• getBookById(id): Handles GET requests to fetch a book by its ID.
• createBook(bookData): Handles POST requests to create a new book.
• updateBook(id, updatedBookData): Handles PUT requests to update an existing book.
• deleteBook(id): Handles DELETE requests to delete a book by its ID.

These methods delegate the actual business logic to the BooksService, which is responsible for interacting with the data source (in-memory JSON structure in this case) and performing the necessary operations.

After implementing the controller and service files our project directory looks like

Run Your Application:

With your API endpoints defined, you can now start your Nest.js application and test your API using tools like Postman or curl. Use the command npm run start:dev to start your application in development mode as shown below

npm run start:dev        

Once our Nest.js application starts successfully!!! you will see the below screen in console

Note: By default Nest.js application runs on port number 3000.

Awesome!, Finally we created a REST API using Nest.js, Let's test our api using Postman. As our book management api uses in-memory db let's create a book record in our db using the below curl :

curl --location 'https://localhost:3000/books' \
--header 'Content-Type: application/json' \
--data '{
    "id": 101,
    "title": "Introduction to NestJS",
    "author": "Anonymous",
    "Description": "This book helps people to learn NestJS"

}'        

Now let's try retrieving the book using curl

curl --location 'https://localhost:3000/books/1'         

The above curl will give output something like below

{
    "id": 1,
    "title": "Book 1",
    "author": "Author 1",
    "description": "Description for Book 1"
}        

Note: you can make use of Postman in order to test the other methods like update, delete & list all books routes of the above api yourself.

Now, you might be asking yourself: 'With so many JavaScript frameworks available for creating REST APIs, why should I choose Nest.js?' Let's dive into this question together and explore what sets Nest.js apart from the rest.

Why Choose Nest.js for REST API Development:

With numerous JavaScript frameworks available for building RESTful APIs, choosing the right one can be a daunting task. However, Nest.js stands out among them for several compelling reasons:

1. TypeScript Support: Nest.js is built with TypeScript, a superset of JavaScript that adds static typing and other advanced features to the language. TypeScript enhances code quality, readability, and maintainability by catching errors at compile-time and providing better tooling support. This makes Nest.js particularly attractive for developers who value strong typing and want to build robust, scalable applications.
2. Modular Architecture: Nest.js promotes a modular architecture, allowing you to organize your code into reusable and maintainable modules. Each module encapsulates related functionality, making it easier to manage and scale your application. This modular approach facilitates code reuse, promotes separation of concerns, and enhances the overall maintainability of your codebase.
3. Decorator-Based Routing: Nest.js uses decorators to define routes and map them to controller methods. This declarative approach makes it intuitive to define API endpoints and specify the HTTP methods they respond to. Decorators provide a clean and concise syntax for defining routes, reducing boilerplate code and improving code readability.
4. Dependency Injection: Nest.js provides built-in support for dependency injection, allowing you to manage dependencies and promote code reusability. Services, controllers, and other components can be injected with their dependencies, facilitating clean and modular code. Dependency injection promotes loose coupling between components, making it easier to test and refactor your code.
5. Middleware Support: Nest.js offers robust middleware support, allowing you to intercept and manipulate incoming HTTP requests and outgoing responses. Middleware can be used to implement cross-cutting concerns like authentication, logging, error handling, and more. This enables you to add functionality to your application in a modular and reusable way, enhancing its flexibility and maintainability.
6. Built-In Testing Utilities: Nest.js provides built-in testing utilities and supports popular testing frameworks like Jest. This makes it easy to write unit tests, integration tests, and end-to-end tests for your application, ensuring its reliability and robustness. Testing is an integral part of the development process, and Nest.js makes it straightforward to write and maintain tests for your codebase.

As now you are aware about different offerings of Nest.js , it's best time to ask you a question ie

When to Choose Nest.js:

You should consider using Nest.js in below scenarios

• Large-Scale Applications: Nest.js is particularly well-suited for building large-scale applications where maintainability, scalability, and code organization are important considerations. Its modular architecture, dependency injection, and TypeScript support make it an ideal choice for complex projects with multiple developers.
• Enterprise Applications: Nest.js is a great choice for building enterprise-grade applications that require high performance, reliability, and maintainability. Its built-in support for features like dependency injection, middleware, and testing utilities make it easy to implement best practices and design patterns commonly used in enterprise development.
• TypeScript Enthusiasts: If you prefer working with TypeScript and enjoy its benefits such as static typing, enhanced tooling support, and improved code quality, then Nest.js is the framework for you. Nest.js leverages the power of TypeScript to provide a developer-friendly and productive environment for building server-side applications.

That's all for this article . If you found this article insightful and want to stay updated on more content like this, be sure to follow me for future articles on Nest.js, TypeScript, and other cutting-edge technologies. Let's continue this journey together as we explore the endless possibilities of modern web development. Thank you for your support and happy coding! ??