What is Nest.js

Creating a Nestjs Project

Project Directory Structure Explanation

Introduction

Creating a module in Nest.js

Creating a Controller

Creating a Service in Nest.js

Getting Oriented

Middleware in Nest.js

Handling exceptions

Transforming Parameters using ParseInt

Validate request body with the class-validator

Middleware

Custom Providers

Injection Scopes

Dependency Injection

Connecting Nest.js application with TypeORM and Postgres

Create an Entity

Create and Fetch Records from the Database

Implementing Pagination

Connecting Nestjs Application with TypeORM and Postgres

One-to-One Relation

Many to Many Relation

One to Many Relation

Relations

User Signup

User Login

Authenticate User with Passport JWT

Role-Based Authentication

Two-Factor Authentication

API Keys Authentication

Authentication & Authorization

Debug Nestjs Application

Migrations in TypeORM

Seeds

Migrations, Seeds and Debugging

Custom Configuration

Schema Validation

Make Hot Reloading Fast

Application Configuration

Setup Swagger

Document Signup Route

Show User Schema

Test Authentication with Swagger

API Documentation with Swagger

Install MongoDB using Docker Compose

Connect with MongoDB and create a schema

Creating Schema

Save a record in MongoDB

Find and delete a Record

Mongoose's Populate function

MonoDB Database

Configure the Developer and Production Environment

Push your source code to GitHub

Deploy the Nest.js Project to Railway

Install dotenv to work with database migrations

Fixing Env Bugs

Deployment

Getting started with Jest

Auto Mocking

SpyOn for additional testing functionality

Unit Test Controller

Unit Test the Song Service

Testing

Speedy Web Compiler with Nest.js v10

Creating Websocket Server

Send Message from Frontend App

Websockets

GraphQL Server Setup

Define Queries and Mutations

Resolve Songs Queries

Resolvers with Song Mutations

Error Handling

Build GraphQL APIs

Define the Schema for Authentication

Authentication Resolvers with Queries and Mutations

Using AuthGuard for authentication

Authenticate GraphQL APIs

Pub sub functionality in GraphQL

Subscriptions in GraphQL

Unit Test Resolver

End To End Testing

Testing GraphQL APIs

Server-Side Caching

Optimize Query Performance using DataLoader

Fetching Data from external REST APIs

GraphQL Advanced Concepts

Setup Prisma

Prisma Models and Migrations

Creating Prisma Service

Create, Find, and FinOne Endpoint

Update and Delete Endpoint

Defining a One-to-Many Relation

Adding One to One Relation

Adding Many to Many Relation

Implement Transaction using Nested Writes

Batch/Bulk Operations

Interactive Transaction

Prisma Integration with Nest.js

File Upload

Custom Decorator

Cron Task Schedule in Nest.js

Cookies

Queues in Nest.js

Event Emitter

Streaming

Nest.js Advanced Concepts

In this course we Welcome to "Nest.js Fundamentals" In this course, we will dive into the core concepts of Nest.js to help you build the foundation for creating your own Spotify clone.

Throughout this journey, our primary focus will be on constructing the backend of a Spotify clone application. We will refrain from any sales language and calls to action, allowing you to focus solely on the essential details of what this course entails.

Stay tuned for a comprehensive learning experience, as we break down the fundamental elements of Nest.js and take the first step toward creating a Spotify-like application from scratch.

In 2023, learning Nest.js opens doors to a world of opportunities and challenges, all of which can significantly enrich your career as a senior software engineer. Here are five compelling reasons why you should consider mastering Nest.js this year:

1. **Cutting-Edge Technology**: Nest.js represents the cutting edge of modern web development. By learning it, you stay at the forefront of industry trends, ensuring your skills remain relevant and valuable.

2. **Scalability and Maintainability**: In today's environment, building scalable and maintainable applications is a top priority. Nest.js, with its modular structure and best practices, equips you to meet these demands effectively.

3. **Diverse Job Opportunities**: Nest.js expertise is in high demand across industries, offering you a wide range of job opportunities. From startups to tech giants, companies are actively seeking developers with Nest.js skills.

4. **Community and Resources**: The Nest.js community is thriving, offering a wealth of resources and support. Learning in 2023 means you have access to a vibrant community eager to help you succeed.

5. **Future-Proofing Your Career**: As technology evolves, your ability to adapt and learn new frameworks becomes increasingly valuable. Nest.js serves as an excellent foundation, allowing you to adapt to new technologies as they emerge.

By learning Nest.js, you position yourself for a successful and fulfilling career. These advantages are part of the course's value proposition, which we present without any sales language or calls to action, allowing you to make an informed decision.

but Learning Nest.js can be a daunting journey, especially if you're new to this technology. As a senior software engineer, you've likely encountered various obstacles when trying to grasp the fundamentals of Nest.js:

- **Complexity:** Nest.js can initially appear complex due to its intricate module structure and extensive ecosystem. Navigating this framework can be overwhelming, leaving you searching for a more structured approach.

- **Integration:** Integrating Nest.js with databases like Postgres and MongoDB, understanding how models relate, and configuring your application can be challenging, particularly for those without prior experience.

- **Testing:** Testing REST and GraphQL APIs can be puzzling, as ensuring your codebase remains bug-free is crucial. Lack of proper guidance and real-world examples can make this process frustrating.

- **Authentication and Security:** Implementing JWT Authentication and Two-Factor Authentication correctly is crucial for any application. Mistakes can result in security vulnerabilities, making it essential to learn these concepts thoroughly.

- **Documentation and Deployment:** Properly documenting your APIs and deploying your application to a live environment can be a source of confusion, causing roadblocks in the development process.

These challenges and frustrations are common among learners new to Nest.js. Our course, "Nest.js Fundamentals," aims to address these hurdles, offering clear, structured guidance without resorting to sales language or calls to action, so you can make an informed decision about your learning path.

In 85 Lessons we cover how to build, secure, and deploy production ready REST APIS and GraphQL APIs. Its 15 hours long and comes with Nest.js fundamentals and advanced concepts

It's taught by Haider Malik who have taught web development to 50,000 students through Udemy, Manning, Packt and FreeCodeCamp

In this course we Nest.js Fundamentals: Building the Backend of a Spotify Clone. Nest.js excels with its powerful combination of TypeScript support and an opinionated structure, simplifying backend development, making code maintainable, and enhancing scalability.
Its modular architecture and extensive ecosystem contribute to efficient and maintainable web applications.
but Learning Nest.js can be challenging due to its extensive documentation and TypeScript dependency, which might be unfamiliar to some.
Navigating complex configurations and building real-world applications may also pose challenges for beginners..

Nest.js Fundamentals

How to build REST APIs with Nest.js, Postgres and MongoDB

How to integrate Postgres, Prisma, and MongoDB

Role-based authentication is a method of access control that regulates user permissions and privileges within a system based on their assigned roles. In this approach, users are categorized into roles based on their job responsibilities, functions, or levels of authority within an organization.

Each role is associated with a set of permissions that determine what actions and resources a user with that role can access. These permissions can include read, write, modify, delete, and other operations on various system resources such as files, databases, or functionalities.

We have to restrict the access of creating songs endpoint. Only artists can access this endpoint and create a song

import { Module } from "@nestjs/common";
import { ArtistsService } from "./artists.service";
import { TypeOrmModule } from "@nestjs/typeorm";
import { Artist } from "./artist.entity";

@Module({
  imports: [TypeOrmModule.forFeature([Artist])],
  providers: [ArtistsService],
  exports: [ArtistsService],
})
export class ArtistsModule {}

import { AuthModule } from './auth/auth.module';


@Module({
imports: [
  PlayListModule,
  UsersModule,
  AuthModule,
  ArtistsModule,
],
})

import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { Repository } from "typeorm";
import { Artist } from "./artist.entity";

@Injectable()
export class ArtistsService {
  constructor(
    @InjectRepository(Artist)
    private artistRepo: Repository<Artist>
  ) {}

  findArtist(userId: number): Promise<Artist> {
    return this.artistRepo.findOneBy({ user: { id: userId } });
  }
}

We will use the findArtist method to check if the current logged in user is an artist or not.

constructor(
private userService: UsersService,
private jwtService: JwtService,
private artistService: ArtistsService,
) {}

---
title: Role-Based Authentication
privateVideoUrl: https://fullstack.wistia.com/medias/i4t0vkpxgq
isPublicLesson: true
---

### What is Role-based Authentication

Role-based authentication is a method of access control that regulates user permissions and privileges within a system based on their assigned roles. In this approach, users are categorized into roles based on their job responsibilities, functions, or levels of authority within an organization.

Each role is associated with a set of permissions that determine what actions and resources a user with that role can access. These permissions can include read, write, modify, delete, and other operations on various system resources such as files, databases, or functionalities.

We are going to implement this scenario:

-   An artist can upload/create the song

We have to restrict the access of creating songs endpoint. Only artists can access this endpoint and create a song

### Create an Artists Module

```ts
import { Module } from "@nestjs/common";
import { ArtistsService } from "./artists.service";
import { TypeOrmModule } from "@nestjs/typeorm";
import { Artist } from "./artist.entity";

@Module({
  imports: [TypeOrmModule.forFeature([Artist])],
  providers: [ArtistsService],
  exports: [ArtistsService],
})
export class ArtistsModule {}
```

### Add ArtistsModule into AppModule

```ts
import { AuthModule } from './auth/auth.module';


@Module({
imports: [
  PlayListModule,
  UsersModule,
  AuthModule,
  ArtistsModule,
],
})
```

### Create ArtistsService

```ts
import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { Repository } from "typeorm";
import { Artist } from "./artist.entity";

@Injectable()
export class ArtistsService {
  constructor(
    @InjectRepository(Artist)
    private artistRepo: Repository<Artist>
  ) {}

  findArtist(userId: number): Promise<Artist> {
    return this.artistRepo.findOneBy({ user: { id: userId } });
  }
}
```

We will use the findArtist method to check if the current logged in user is an artist or not.

### Refactor login method in AuthService

```ts
constructor(
private userService: UsersService,
private jwtService: JwtService,
private artistService: ArtistsService,
) {}
```

You have to inject the artist's service in the `AuthService` constructor

```ts
const payload: PayloadType = { email: user.email, userId: user.id }; // 1

// find if it is an artist then the add the artist id to payload
const artist = await this.artistService.findArtist(user.id); // 2
if (artist) {
  // 3
  payload.artistId = artist.id;
}
```

1.  Refactor the payload method in the login function by changing `sub: user.id` to `userId: user.id`.
2.  Find the artist based on the logged-in user.
3.  If the user is an artist, save the artist ID in the payload; this artist ID will be used when decoding the token in the ArtistGuard.