Building a NestJS Application with MongoDB: A Complete Guide

Last updated on June 18th, 2023

Introduction:

NestJS Application with MongoDB: In the world of web development, creating robust and scalable applications is crucial. NestJS, a progressive Node.js framework, offers an elegant solution for building server-side applications. When combined with MongoDB, a powerful NoSQL database, NestJS can deliver efficient and flexible backend systems. In this article, we will explore the process of building a NestJS application with MongoDB, from setting up the project to implementing CRUD operations.

1. Setting Up a NestJS Project: To begin, we need to set up a new NestJS project. We’ll guide you through the installation of the necessary dependencies and the basic project structure. We’ll also discuss how to configure MongoDB as our database and establish a connection between NestJS and MongoDB.
2. Creating MongoDB Models: Next, we’ll dive into creating MongoDB models using the Mongoose library. We’ll explain how to define schemas and models, and how to establish relationships between different collections in MongoDB. You’ll learn how to handle validations and implement various data manipulations using Mongoose.
3. Building RESTful APIs: NestJS excels at creating RESTful APIs, and we’ll demonstrate how to leverage its capabilities. We’ll guide you through the process of creating controllers, services, and DTOs (Data Transfer Objects) for handling incoming requests and executing corresponding actions on the MongoDB database. You’ll learn how to implement CRUD operations (Create, Read, Update, Delete) using NestJS decorators and Mongoose methods.
4. Implementing Authentication and Authorization: Security is a vital aspect of any application. We’ll explore how to integrate authentication and authorization mechanisms into our NestJS application. You’ll learn how to use tools like Passport and JWT (JSON Web Tokens) to authenticate users and authorize access to protected routes. We’ll discuss strategies for storing hashed passwords and securing sensitive user data.
5. Handling Advanced MongoDB Features: MongoDB offers numerous advanced features that can enhance the functionality of our application. We’ll cover topics such as indexing, aggregation pipelines, and geospatial queries. You’ll discover how to leverage these features in NestJS to optimize performance and implement complex querying operations.
6. Testing NestJS with MongoDB: No application is complete without thorough testing. We’ll guide you through the process of writing unit tests and integration tests for your NestJS application with MongoDB. We’ll discuss tools like Jest and Supertest and show you how to set up a test environment and write comprehensive test cases for your APIs.
7. Deployment and Production Considerations: Finally, we’ll address the deployment and production considerations for a NestJS application with MongoDB. We’ll explore options such as containerization with Docker, using platforms like Heroku or AWS, and scaling your application to handle increased traffic. We’ll also discuss logging, monitoring, and error handling strategies to ensure smooth operation in production.

Here’s an example of a simple NestJS application with MongoDB that demonstrates CRUD operations for managing a collection of users.

1. Setting Up a NestJS Project: First, let’s create a new NestJS application with MongoDB project and install the necessary dependencies.

# Create a new NestJS project
npx @nestjs/cli new nest-mongo-app

# Navigate into the project directory
cd nest-mongo-app

# Install required dependencies
npm install mongoose @nestjs/mongoose

2. Creating MongoDB Models: Next, let’s create a user model using Mongoose. Create a new file called user.model.ts in the src directory with the following content:

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

@Schema()
export class User extends Document {
  @Prop({ required: true })
  name: string;

  @Prop({ required: true })
  email: string;

  @Prop()
  age: number;
}

export const UserSchema = SchemaFactory.createForClass(User);

3. Establishing a Connection to MongoDB: In the app.module.ts file, configure the connection to your MongoDB database. Update the file with the following code:

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { User, UserSchema } from './user.model';

@Module({
  imports: [
    MongooseModule.forRoot('mongodb://localhost/nest-mongo-app'),
    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
  ],
})
export class AppModule {}

4. Building RESTful APIs: Create a new controller called user.controller.ts in the src directory to handle the user-related routes:

import { Controller, Get, Post, Body, Param, Put, Delete } from '@nestjs/common';
import { UserService } from './user.service';
import { CreateUserDto, UpdateUserDto } from './user.dto';

@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Get()
  findAll() {
    return this.userService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.userService.findOne(id);
  }

  @Post()
  create(@Body() createUserDto: CreateUserDto) {
    return this.userService.create(createUserDto);
  }

  @Put(':id')
  update(@Param('id') id: string, @Body() updateUserDto: UpdateUserDto) {
    return this.userService.update(id, updateUserDto);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.userService.remove(id);
  }
}

5. Creating a Service: Create a new file called user.service.ts in the src directory to handle the user-related business logic:

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { User, UserDocument } from './user.model';
import { CreateUserDto, UpdateUserDto } from './user.dto';

@Injectable()
export class UserService {
  constructor(@InjectModel(User.name) private userModel: Model<UserDocument>) {}

  async findAll(): Promise<User[]> {
    return this.userModel.find().exec();
  }

  async findOne(id: string): Promise<User> {
    return this.userModel.findById(id).exec();
  }

  async create(createUserDto: CreateUserDto): Promise<User> {
    const createdUser = new this.userModel(createUserDto);
    return createdUser.save();
  }

  async update(id: string, updateUserDto: UpdateUserDto): Promise<User> {
    return this.userModel.findByIdAndUpdate(id, updateUserDto, { new: true }).exec();
  }

  async remove(id: string): Promise<User> {
    return this.userModel.findByIdAndRemove(id).exec();
  }
}

6. DTOs (Data Transfer Objects): Create two DTOs, user.dto.ts, in the src directory to define the shape of the data transferred between the client and the server:

export class CreateUserDto {
  name: string;
  email: string;
  age: number;
}

export class UpdateUserDto {
  name?: string;
  email?: string;
  age?: number;
}

7. Running the Application: Finally, start the NestJS application by running the following command:

npm run start

You can now test the API endpoints for managing users by sending HTTP requests to http://localhost:3000/users. Use tools like Postman or cURL to interact with the API and perform CRUD operations on the MongoDB database.

Conclusion:

By combining the power of NestJS application with MongoDB, you can build highly scalable and efficient backend applications. In this article, we’ve covered the entire process, from setting up the project to deploying it in production. Armed with this knowledge, you’re now equipped to create your own NestJS application with MongoDB, taking advantage of its flexibility and performance. Happy coding!