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 manage server-side operations for diverse user interfaces

To control what different users can see and do within the application

What is the primary purpose of role-based access control in a web application?

What is the primary purpose of role-based access control in a web application?

  ```javascript
  @Injectable()
  export class AccessControlGuard implements CanActivate {
    canActivate(): boolean {
      // Retrieve roles logic...
    }
  }
  ```

```javascript
 @Injectable()
 export class AccessControlGuard implements CanActivate {
 constructor(private reflector: Reflector) {}

 canActivate(context: ExecutionContext): boolean {
 const roles = this.reflector.getRoles<string[]>('roles', context.getClass());
 
 }
 }
 ```

```javascript
 @Injectable()
 export class AccessControlGuard implements CanActivate {
 constructor(private reflector: Reflector) {}

 canActivate(context: ExecutionContext): boolean {
 const roles = this.reflector.get<string[]>('roles', context.getHandler());
 
 }
 }
 ```

  ```javascript
@Injectable()
  export class AccessControlGuard implements CanActivate {
    canActivate(context: ExecutionContext): boolean {
      const roles = context.switchToHttp().getRequest().roles;
      
    }
  }

````

Consider the following controller:

```
@UseGuards(AccessControlGuard)
@Controller('books')
export class BooksController {
  @Get()
  @Roles(Role.Admin)
  findAll() {
     
  }
}
```

Which guard implementation correctly retrieves the role set by the `Roles` decorator?

Consider the following controller:
<pre><code>@UseGuards(AccessControlGuard)
@Controller('books')
export class BooksController {
 @Get()
 @Roles(Role.Admin)
 findAll() {
 
 }
}
</code></pre>
Which guard implementation correctly retrieves the role set by the <code>Roles</code> decorator?

To define new routes for different user roles

To apply middleware for user authentication

To enforce role-based access control on all routes within the controller

What is the use of `@UseGuards()` in the following code when implementing role-based authorization?

```typescript
@UseGuards(AccessControlGuard)
@Controller('users')
export class UsersController {
  
}
```

What is the use of <code>@UseGuards()</code> in the following code when implementing role-based authorization?
<pre><code class="language-typescript">@UseGuards(AccessControlGuard)
@Controller('users')
export class UsersController {
 
}
</code></pre>

Test your understanding of authorization 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

Build a Rest API for an Image-Sharing App With Node.js

Quiz on Authorization