Gain insights into building scalable backend applications with NestJS. Explore modules, REST API, TypeORM, JWT authentication, and automated testing to advance your backend development skills.

hello-world.tar.gz

nest-first-app

nest-starter

nest-starter-build

nest-starter-start-in-prod

nest-starter-start-module-controller-service

nest-starter-start-generate-resource

database-agnostic

nest-global-module

nest-scope

books-api

books-api-database

books-api-database-configuration

books-api-database-configuration-joi

books-api-database-configuration-default-env

books-api-database-configuration-dev-env

nest-react-hashing

books-api-test-auth-service

books-api-test-end-to-end

nest-react-spa

nest-react-bcrypt

In this course, you will cover NestJS, a framework used to build efficient and reliable server-side applications. Using this framework, developers can make highly scalable backend applications that can be consumed with any type of frontend. 

You will start the course by learning the foundational blocks of NestJS, such as understanding modules, services, and controllers. Next, you will learn how to build REST API, validation and error handling. You will also learn database integration using TypeORM, app configuration using environment variables, authentication, and authorization using JWT tokens. You will complete this course by learning automated testing and application logging.

After completing this course, you will be equipped with all the necessary skills to build scalable backend applications using NestJS, and that will also advance your career in backend development.

Building a Back-End Application with NestJS

To test individual components in isolation

To check the application overall functionality

To test the application performance under load

To verify the integration between different modules

What is the primary purpose of unit testing in web applications?

What is the primary purpose of unit testing in web applications?

Testing the smallest parts of an application independently

Testing the complete flow of an application from start to finish

Testing the application response to external events

Testing the application database connectivity

Which best describes end-to-end (E2E) testing?

Which best describes end-to-end (E2E) testing?

To ensure the `findOne` method always throws an error

To simulate a response from the `findOne` method for testing

To speed up the execution of the `findOne` method

To bypass the `findOne` method in production

Consider the following code snippet: 

````typescript
const user = { id: 1, email: 'valid@example.com', password: 'hashedPassword', role: 'admin' };
userRepository.findOne.mockResolvedValue(user);
````

What is the purpose of `mockResolvedValue()`?

Consider the following code snippet:
<pre><code class="language-typescript">const user = { id: 1, email: 'valid@example.com', password: 'hashedPassword', role: 'admin' };
userRepository.findOne.mockResolvedValue(user);
</code></pre>
What is the purpose of <code>mockResolvedValue()</code>?

To ensure the `signUp` function creates a new user

To verify that the `signUp` function throws an exception for a duplicate email

To test the database performance during user signup

To check if the `signUp` function returns a user object

Consider the following code snippet:

````typescript
it('should throw a ConflictException for duplicate email', async () => {
   const signUpDto = { email: 'valid@example.com', password: 'password123' };
   const existingUser = { id: 1, email: 'valid@example.com', password: 'hashedPassword' }; 
   userRepository.findOne.mockResolvedValue(existingUser);
   await expect(authService.signUp(signUpDto)).rejects.toThrow(ConflictException);
});
````

What is its primary objective?

Consider the following code snippet:
<pre><code class="language-typescript">it('should throw a ConflictException for duplicate email', async () =&gt; {
 const signUpDto = { email: 'valid@example.com', password: 'password123' };
 const existingUser = { id: 1, email: 'valid@example.com', password: 'hashedPassword' }; 
 userRepository.findOne.mockResolvedValue(existingUser);
 await expect(authService.signUp(signUpDto)).rejects.toThrow(ConflictException);
});
</code></pre>
What is its primary objective?

Test your understanding of testing in NestJS.

Introduction

Getting Started

NestJS CLI

Building a REST API

Validation and Error Handling

Working with Databases

App Configuration

Authentication

Authorization

Testing

Logging

Wrapping Up

Quiz on Testing in NestJS