In this article, I will explain how to develop a sample application using NestJS and MongoDB, leveraging the functionalities provided by the monguito
, a lightweight and type-safe library to seamlessly create custom database repositories for Node.js applications.
The sample application is a book manager that includes features such as creating, updating, deleting, and finding books. I will also provide step-by-step instructions for installing and running the application.
For those eager to get to the code of the sample application, you can find it at this Github repository. You may also find a further explanation on the monguito
library at this other article.
The Domain Model
The application domain model is pretty simple: Book
is a supertype that specifies two subclasses i.e., PaperBook
and AudioBook
. Here is its definition:
export class Book implements Entity {
readonly id?: string;
readonly title: string;
readonly description: string;
constructor(book: {
id?: string;
title: string;
description: string;
}) {
this.id = book.id;
this.title = book.title;
this.description = book.description;
}
}
export class PaperBook extends Book {
readonly edition: number;
constructor(paperBook: {
id?: string;
title: string;
description: string;
edition: number;
}) {
super(paperBook);
this.edition = paperBook.edition;
}
}
export class AudioBook extends Book {
readonly hostingPlatforms: string[];
constructor(audioBook: {
id?: string;
title: string;
description: string;
hostingPlatforms: string[];
}) {
super(audioBook);
this.hostingPlatforms = audioBook.hostingPlatforms;
}
}
Entity
is an interface created to assist developers in the implementation of type-safe domain models. It specifies an id
field that all Book
or subclass instances must include. This is because id
is assumed to be the primary key of any stored book. However, you do not need to implement Entity
if you do not want to; simply make sure that your superclass includes an id
field in its definition.
The Repository
Here a simple definition of a custom repository for books:
@Injectable()
export class MongooseBookRepository
extends MongooseRepository<Book>
implements Repository<Book>
{
constructor(@InjectConnection() connection: Connection) {
super(
{
Default: { type: Book, schema: BookSchema },
PaperBook: { type: PaperBook, schema: PaperBookSchema },
AudioBook: { type: AudioBook, schema: AudioBookSchema },
},
connection,
);
}
}
Repository
is a Typescript generic interface that specifies some common CRUD database operations that can be executed on any persistent domain object. MongooseRepository
, on another hand, is a Mongoose-based implementation of the interface that provides you with all the boilerplate code required to execute those operations. You can find further details on both Repository
and MongooseRepository
in this article. I would personally recommend you read the section Some Important Implementation Details to gain some required knowledge on the logic expected for your custom repository constructor, specially if your domain model is polymorphic i.e., if you want to store instances of a type and/or its subtypes in the same MongoDB collection.
You may also have some further questions regarding the Injectable
and InjectConnection
decorators. Please be patient, I will address them soon enough in this article 😉.
The Controller
The controller is the entry point of external requests to the book manager application. Here is how it looks like:
type PartialBook = { id: string } & Partial<Book>;
function deserialise<T extends Book>(plainBook: any): T {
let book = null;
if (plainBook.edition) {
book = new PaperBook(plainBook);
} else if (plainBook.hostingPlatforms) {
book = new AudioBook(plainBook);
} else {
book = new Book(plainBook);
}
return book;
}
@Controller('books')
export class BookController {
constructor(
@Inject('BOOK_REPOSITORY')
private readonly bookRepository: Repository<Book>,
) {}
@Get()
async findAll(): Promise<Book[]> {
return this.bookRepository.findAll();
}
@Post()
async insert(
@Body({
transform: (plainBook) => deserialise(plainBook),
})
book: Book,
): Promise<Book> {
return this.save(book);
}
@Patch()
async update(
@Body()
book: PartialBook,
): Promise<Book> {
return this.save(book);
}
@Delete(':id')
async deleteById(@Param('id') id: string): Promise<boolean> {
return this.bookRepository.deleteById(id);
}
private async save(book: Book | PartialBook): Promise<Book> {
try {
return await this.bookRepository.save(book);
} catch (error) {
throw new BadRequestException(error);
}
}
}
You may argue several things here. For starters, you may think that an enterprise application should delegate business/domain logic to a layer of service objects as described in e.g., Domain-Driven Design (tactical design). I have decided not to do so for simplicity purposes; the book manager presented in this article is such an extremely simple CRUD application that introducing services would be over-engineering. I rather implement the minimum amount of code necessary for the sake of maximising the actual purpose of the article: illustrate how to integrate the monguito
library on a NodeJS-based enterprise application.
Moreover, you would probably not write a deserialise
function to enable the transformation of JSON request bodies into domain objects when dealing with POST
requests. Instead, you would rather use a NestJS pipe to do so, thus properly complying with the Single Responsibility principle. Once again, I wanted to share the simplest possible working example at the expense of not conveying to the recommended practices in NestJS application construction. That being said, I would highly recommend you to read this section on how to use class-validator
and class-transformer
for the validation and deserialisation of JSON request bodies in the development of complex enterprise applications.
Okay! So all is missing now is how to tell the controller to use the custom book repository at runtime. This is where we are going next.
The Application Module
NestJS implements the Dependency Inversion principle; developers specify their component dependencies and NestJS uses its built-in dependency injector to inject those dependencies during component instantiation.
So, how do we specify the dependencies of the components that compose the book manager sample application? There are two easy steps that we need to take: The first step consists of writing some decorators in the MongooseBookRepository
and BookController
classes, as I already did in the code definition for both. The former class specifies that its instances are Injectable
to other components. It also specifies that to instantiate a book repository, NestJS needs to inject a Mongoose connection. This is done with the InjectConnection
decorator related to the connection
constructor input parameter.
On another hand, the definition of BookController
specifies that, during instantiation, the controller consumes an instance of a Repository<Book>
defined by the BOOK_REPOSITORY
custom token.
The definition of the custom token is part of the second step: writing the last required class: AppModule
. The definition of this class is as follows:
@Module({
imports: [
MongooseModule.forRoot('mongodb://localhost:27016/book-repository'),
],
providers: [
{
provide: 'BOOK_REPOSITORY',
useClass: MongooseBookRepository,
},
],
controllers: [BookController],
})
export class AppModule {}
The Module
decorator of this class specifies the Mongoose connection required to instantiate MongooseBookRepository
at the imports
property. It also determines that any component that has a dependency with the provider
identified by the BOOK_REPOSITORY
custom token is to get an instance of MongooseBookRepository
. Finally, it determines that BookController
is the sole controller for the book manager application.
Running the Application
Once you have implemented the book manager in your own or cloned the monguito
GitHub project, and assuming that you have NestJS installed in your local machine, there are two further prerequisites to satisfy before you can run the application.
You must install all the project dependencies specified at the package.json
file. To do so, simply execute the yarn install
command from the root folder of the project. If you have cloned the library project, that folder is examples/nestjs-mongoose-book-manager
.
The second prerequisite is installing Docker Desktop (in case you have not done it yet) and launching it in your local machine. I wrote a docker-compose.yml
file to create a Docker container with an instance of the latest MongoDB version for your convenience, but you may create your own otherwise.
Then, all you need to do is run yarn start:dev
. You will then be able to access all the endpoints specified at BookController
via e.g., the curl
command or Postman.
Conclusion
After following the several steps required to build an easy web application that integrates monguito
, I hope that you are now able to leverage your knowledge and build your own. If you are willing to create a complex application, I also hope I has been able to provide you with a bit of guidance. Otherwise, please leave me a comment and I will get back to you ASAP 😊.
Cover image by Michael Sum on Unsplash.
Top comments (0)