Guided: Databases and TypeORM in NestJS

Welcome to the Guided: Databases and TypeORM in NestJS Lab

Throughout this lab, you will become familiar with how PostgreSQL, a popular database option, is integrated with a NestJS application. You will use TypeORM, an Object-Relational Mapper (ORM), to interact with the relational database, PostgreSQL.

This lab will have you do the following:

• Configure a NestJS application to use TypeORM with PostgreSQL.
• Define database tables using TypeORM's Entity decorator.
• Manage database relationships.
• Create and run migrations.
• Perform interactions with the database using the supported TypeORM Repository pattern.
• Handle database transactions.
• Optimize database queries.

A basic understanding of Typescript and NestJS will be useful to complete this lab, but it is not necessary. Specific knowledge required to complete this lab will be provided.

For the purposes of this lab, any packages or libraries that serve as a dependency for the completion of this lab are already installed for you.

You may find three Terminal windows helpful while you complete this lab. One for running the client, another for running the server, and a third one to run migrations. You will not be starting the application until you have implemented parts of the PostsService in a future step.

--- > Throughout the next steps, you can refer to the /solution directory at any point if you need assistance. The /solution directory contains subdirectories for each of the following steps.

Overview of TypeORM

TypeORM is an Object-Relational Mapper (ORM) for TypeScript and JavaScript that allows developers to interact with relational databases using object-oriented syntax instead of writing raw SQL queries. It is widely used with frameworks like NestJS and supports databases such as PostgreSQL and others.

It is preferred to use TypeORM along with NestJS applications because TypeORM facilitates the following:

• TypeScript support – Seamless integration with NestJS
• Ease of use – Uses decorators for defining schemas
• Scalability – Works well with large-scale applications
• Extensibility – Supports advanced database features like caching and transactions

Configure TypeORM with PostgreSQL in NestJS

The PostgreSQL database, nestjs_db, has been created for you. The PostgreSQL user, myuser, has also been created for you with the password, mypassword. This password is not a great production password, but it works for this lab scenario. myuser has been granted the proper permissions to connect with the database, nestjs_db, and perform migrations. The user, myuser, will also be able to read and write to the database.

The NestJS application will connect to the database, nestjs_db, using myuser. The TypeOrmModule has a method, called forRoot, that is used to configure the PostgreSQL database connection globally. It also sets up the TypeORM connection and makes it available throughout the app.

In this step, you will use TypeOrmModule.forRoot() in the root module, AppModule, to configure the NestJS application to connect to the PostgreSQL database,nestjs_db. You will do this with under the myuser user at port 5432 and host localhost. When you configure TypeORM with PostgreSQL in the root module, it will establish the database connection when the application starts.

The root module provided is bare bones and only contains global imports for the Posts and Comments modules. Complete the tasks below to configure the NestJS application to use TypeORM with PostgreSQL.

In the previous task, you hard coded database credentials (like username, password, host) in /server/app.module.ts. Even though this is enough to start using TypeORM to interact with the PostgreSQL database throughout the NestJS application, it is recommended to use environment variables to configure TypeORM with PostgreSQL in NestJS.

Using environment variables for credentials is encouraged to protect sensitive information, enable environment-specific configurations, simplify deployment and configuration management with cloud providers, and improve code maintainability.

In the next task, you will update /server/app.module.ts to use the environmental variables provided to you in /server/.env.

Use TypeORM Decorators to Design and Implement Database Entities

Using TypeORM decorators, you can define database tables as TypeScript classes.

In this step, you will be defining and implementing the Post database entity. A Post will have the following columns:

• id: number
• content: string
• title: string

A file for the Post entity has been provided at server/src/post/post.entity.ts. In the upcoming tasks, you will be making changes to this file. Any imports or dependencies needed to complete this step have already been included for you.

Design and Implement Comment Entity

In this step, you will be defining and implementing the Comment entity. A Comment will have the following columns:

• id: number
• content: string

A file for the Comment entity has been provided at /server/src/comments/comment.entity.ts. In the upcoming tasks, you will be making changes to this file. Any imports or dependencies needed to complete this step have already been included for you.

Manage Database Relationships within Database Entities

If you have worked with a relational database before, you are probably familiar with the concept of relations. Relations allow you to create entities that are related and interact with them seamlessly.

TypeORM supplies decorators that can be used on a database entity to specify the following types of relationships:

• One-to-One
• Many-to-One
• One-to-Many
• Many-to-Many

In this NestJS forum application, a Post can be associated with many Comments, but a Comment can only be associated with one Post. You will also want to delete all comments on the post when the post is deleted. This deletion process is referred to as cascade deletion.

Create and Run Database Migrations

Right now, you would see your nestjs_db database has no tables if you were to inspect the database contents using the psql command interface.

You want to create the Post and Comment entities from the previous step as database tables with the correct table columns using migrations. To do this, you will use the typeorm-ts-node-commonjs command to create the migration SQL file and run it.

You are given a TypeORM data source file in /server/src/database/data-source.ts. This file does the following:

• Imports the Comment entity
• Imports the Post entity
• Imports DataSource from 'typeOrm'
• Specifies to TypeORM which entities to watch for definition changes
• Specifies where to store migration SQL files
• Specifies database configuration details

This file will be passed as the data source file using the -d flag to tell TypeORM which database configuration file to use for the migration.

Start the Forum Application

You will use the forum application, Post It, provided to test the changes you will make to the PostsService and CommentsService over the next four steps.

This application is a React front-end built to interact with the NestJS server you will be finishing. The routes the front-end needs to operate are already implemented by the PostsController and CommentsController and are calling the PostsService and CommentsService to handle interactions with the database.

At this time, all methods in the PostsService and CommentsService are throwing NotImplementedException exceptions. This is why you will see in the client interface toasts indicating that requests are failing.

As you implement methods in the related services, you will be able to use the forum application client interface to determine if your NestJS server is reading and writing to the database correctly.

Note: When a NestJS application is created from scratch via the NestJS Command Line Interface (CLI) with the command nest new <project_name>, the start:dev script starts the application in watch mode. This means it does not need to be restarted after changes are made to the server code. When changes are made to the server code in watch mode, the process can detect these changes and recompile as needed.

--- ## Visit the Client Forum Application Interface

Open the SimpleBrowser tab and click the refresh button, or click this link to open in another browser: {{localhost:3000}}.

When the application has been started, you will see a table with no posts and a couple buttons to Create a Post and Generate a Random Post with Random Comments. You will see pop-ups indicating failure while loading posts. As you implement the appropriate service methods, these requests will start working.

Feel free to go to the window where you are running the forum application client interface anytime to test changes in the upcoming steps.

Registering an Entity in a Feature Module

You need to register an entity in a feature's module to have access to an entity repository or entity class in a feature's service. This can be done with the TypeOrmModule.forFeature() method.

If you want to import a feature entity into controller or service (even if you do not need to inject the entity's repository), you will need to include it in the list of feature's being registered in the feature's module.

--- ## The Repository Pattern

The Repository Pattern is a software design pattern that provides an abstraction layer between the application and the data persistence layer, such as a database. It encapsulates data access logic, making it easier to manage, test, and modify database interactions without directly coupling the business logic to the database.

TypeORM Repositories

In NestJS, the repository pattern is naturally integrated when using TypeORM, which provides built-in repository functionality via the Repository class. The Repository class is often injected into an feature's service and you have to inject a Repository for each entity you will be interfacing with data wise and register that entity in the feature's module.

--- ## Implement the Post Service Utilizing TypeORM's Repository for the Post Data Entity

With the client application running, you will soon be able to verify the changes that you make to the PostsService class in /server/src/posts/posts.service.ts are working.

Follow the tasks below to learn more about how to interact with the Post entity database table using the repository pattern.

All dependencies you will need to complete the following tasks have been installed for you and any necessary imports have already been imported for you. ## Test Code Changes Using Client Interface

Visit the forum application wherever you have it running. You should now be able to view all, search for, create, edit, and delete posts. You should also be able to view a specific post and its related comments by clicking on the post's title in the table. You will still be able to see changes to posts even after refreshing the client interface. This is evidence that data is being persisted to the database.

You currently should not be able to see paginated post results or generate random posts with comments. These will be implemented over the next two steps.

Implement the Comment Service Utilizing TypeORM's Repository

Complete this step for extra repository practice with entities that relate to one another and a functioning client interface that can create, update, and delete comments.

In the client interface, comments can be seen on an associated post, created on a specific post, deleted from the comment table on a post, and updated by double clicking the comment. Use the client interface as you complete the tasks below to verify that the NestJS application is interacting with the Comment table in the PostgreSQL database. ## Test Code Changes Using Client Interface

You should now be able to return to your client interface and create, update, and delete comments.

Database Transactions

A database transaction is a sequence of one or more database operations that are executed as a single unit of work. Transactions ensure that either all operations in the sequence are successfully completed or none of them are applied, maintaining data integrity and consistency.

Database Transactions with TypeORM

Database transactions are possible in TypeORM by using the application's DataSource object to create a QueryRunner object that can connect to the database and interact with the database.

In this step, you will implement the createPostWithComments method on the PostsService using TypeORM database transactions. This service is found at /server/src/posts/posts.service.ts.

In order to perform database transactions using TypeORM, you will need to inject an instance of a TypeORM DataSource into your PostsService. After that, the DataSource instance can create a QueryRunner and manage a database transaction.

Note: In the past, you had to import the appropriate entities in your feature module. You did not need to import DataSource in your feature module because you imported it in the root module, AppModule, in step two. This means that this NestJS application's DataSource is available in all features. ## Test Code Changes Using Client Interface

If you go to your client interface, you can now generate random posts with a random number of comments from one to five. This will create the body that will be provided to your createPostWithComments service method.

At this time, generate some random posts in the client interface, this will help with the next step on optimization (specifically pagination).

Optimization

When working with a database, you will at times need to optimize things to improve performance.

API Optimization via Pagination

Pagination speeds up requests by only fetching a subset of data. The subset of data is then rendered on a page, and the next subset of data is fetched when the next page is visited. Pagination often works by limiting the amount of data fetched by requesting a page size and offsetting where data starts based on the page size and current page.

In this step, you will implement pagination when fetching posts. The paginated request is made from the Paginated Posts tab in the client interface. To check out the code changes you are going to make, go to the Paginated Posts tab. You will begin to see the Posts table paginate when you have created more than five posts.

--- ## Test Code Changes Using Client Interface

In the client interface, visit Paginated Posts. You will see a table that displays five posts on each page. If you look into the Developer Tools Network tab, you should see a new request for each page's data. The method you implemented in the task above correctly fetches the pages data.

Conclusion

Congratulations on completing all of the steps of this lab! You now have the skills to integrate a PostgreSQL database with a NestJS application and interact with it using TypeORM entities, repositories, and migrations. You now have a better understanding of API optimizations and how to perform database transactions, including rolling back data in case of failures. This was no easy feat so always take the time you deserve to reward yourself. For more information on TypeORM, you can look at the TypeORM documentation.