Top 8 Recommended NestJS Self-Study Materials! [November 2024]

Authentication/Authorization? Covered.  Automated Testing? Yep, it's here!  Production Deployment? Of course!

Congratulations! You've found the complete guide on how to build enterprise-ready apps with NestJS.

NestJS is a backend framework used to create scalable and reliable APIs.  It is a "battery-included" framework; it includes tools to handle just about every possible use case, from data persistence, to validation, to config management, to testing, and much, much more.  This course will help you master Nest. By the time you complete this course, you will have the confidence to build any app you can imagine.

Throughout this course you will build a series of apps with growing complexity.  We use as few libraries and tools as possible.  Instead, you will write many custom systems to better understand how every piece of Nest works together.  Each application you build includes discussion on data modeling and persistence. We will first save records in a simple file-based data store (built from scratch) and eventually work our way up to saving data in a production-grade Postgres instance.

Testing is a fundamental topic in Nest. A tremendous amount of functionality in Nest is dedicated to making sure your project is easy to test. This course follows Nest's testing recommendations, and you will write both integration and unit tests to ensure your project is working as expected. Although testing can sometimes be confusing and boring, I have put special care into making sure the tests we write are expressive, fast, and effective.  You will be able to use this knowledge on your own projects, even those that don't use Nest!

Typescript is used throughout this course to make sure we are writing clean and correct code. Don't know Typescript? Not a problem! A free appendix is included at the end of the course to get you up to speed on Typescript.  Once you're familiar with it, Typescript will help you catch errors and bugs in your code before you even run it.  If you've never used Typescript before you are in for a treat :)

--------------------------------------

Everything in this course is designed to make your learning process as easy as possible.

• At every step, I will teach you what Nest is doing internally, and help you understand how to twist and bend Nest to better suit your application's needs. 

• Every single video in the course has an attached ZIP file containing up-to-date code, just in case you ever get stuck.

• Full-time teaching assistants are standing by to help answer your questions

• Access private live chat server is included. Live help whenever you need it!

--------------------------------------

Here's a partial list of the topics included in this course:

• Securely deploy your app to production

• Write automated integration and unit tests to make sure your code is working

• Build an authentication system from scratch to log users in

• Allow users to perform certain actions with a permissions system

• Store and retrieve data with complex queries using TypeORM

• Understand how TypeORM handles data relationships

• Write declarative code using property, method, and parameter decorators

• Master the concept of dependency injection to write reusable code

• Implement automatic validation of incoming requests

• Format outgoing response data with a custom DTO system

• Handle incoming requests and outgoing responses using Guards and Interceptors

• Segment your code into reusable Nest Modules

• Add structure to your database using migrations

  
  

I had a tough time learning NestJS.  There are a tremendous number of outdated tutorials around it, the documentation is sometimes unclear, and Nest itself is just plain hard to understand.  I made this course to save you time and money - a course to show you exactly what you need to know about every topic in Nest.  You will find learning Nest to be a delightful experience and pick up a tremendous amount of knowledge along the way.

Sign up today and join me in mastering NestJS!

1. Get Started Here!
2. How to Get Help
3. Join Our Community!
4. Course Resources
5. The Basics of Nest
6. Project Setup
7. TypeScript Configuration
8. Creating a Controller
9. Starting Up a Nest App
10. File Naming Conventions
11. Routing Decorators
12. Generating Projects with the Nest CLI
13. App Setup
14. Using the Nest CLI to Generate Files
15. More on Generating Files
16. Adding Routing Logic
17. [Optional] Postman Setup
18. [Optional] VSCode REST Client Extension
19. Validating Request Data with Pipes
20. Accessing Request Data with Decorators
21. Installing Extra Required Libraries
22. Using Pipes for Validation
23. Adding Validation Rules
24. Behind the Scenes of Validation
25. How Type Info is Preserved
26. Nest Architecture: Services and Repositories
27. Services and Repositories
28. Implementing a Repository
29. Reading and Writing to a Storage File
30. Implementing a Service
31. Manual Testing of the Controller
32. Reporting Errors with Exceptions
33. Understanding Inversion of Control
34. Introduction to Dependency Injection
35. Refactoring to Use Dependency Injection
36. Few More Notes on DI
37. Nest Architecture: Organizing Code with Modules
38. Project Overview
39. Generating a Few Files
40. Setting Up DI Between Modules
41. More on DI Between Modules
42. Consuming Multiple Modules
43. Modules Wrapup
44. Big Project Time!
45. App Overview
46. API Design
47. Module Design!
48. Generating Modules, Controllers, and Services
49. Persisting Data with TypeORM
50. Persistent Data with Nest
51. Setting Up a Database Connection
52. Creating an Entity and Repository
53. Viewing a DB's Contents
54. Understanding TypeORM Decorators
55. One Quick Note on Repositories
56. A Few Extra Routes
57. Setting Up Body Validation
58. Manual Route Testing
59. Creating and Saving User Data
60. Creating and Saving a User
61. Quick Breather and Review
62. More on Create vs Save
63. Required Update for find and findOne Methods
64. Querying for Data
65. Updating Data
66. Removing Users
67. Finding and Filtering Records
68. Removing Records
69. Updating Records
70. A Few Notes on Exceptions
71. Custom Data Serialization
72. Excluding Response Properties
73. Solution to Serialization
74. How to Build Interceptors
75. Serialization in the Interceptor
76. Customizing the Interceptor's DTO
77. Wrapping the Interceptor in a Decorator
78. Controller-Wide Serialization
79. A Bit of Type Safety Around Serialize
80. Authentication From Scratch
81. Authentication Overview
82. Reminder on Service Setup
83. Implementing Signup Functionality
84. [Optional] Understanding Password Hashing
85. Salting and Hashing the Password
86. Creating a User
87. Handling User Sign In
88. Setting up Sessions
89. Changing and Fetching Session Data
90. Signing in a User
91. Getting the Current User
92. Signing Out a User
93. Two Automation Tools
94. Custom Param Decorators
95. Why a Decorator and Interceptor
96. Communicating from Interceptor to Decorator
97. Small Fix for CurrentUserInterceptor
98. Connecting an Interceptor to Dependency Injection
99. Globally Scoped Interceptors
100. Preventing Access with Authentication Guards
101. Getting Started with Unit Testing
102. Testing Overview
103. Testing Setup
104. Yes, Testing is Confusing
105. Getting TypeScript to Help With Mocks
106. Quick Note to Help Speed Up Your Tests
107. Improving File Layout
108. Ensuring Password Gets Hashed
109. Refactor 'Email in Use' Test to Address Jest Breaking Changes
110. Changing Mock Implementations
111. Refactor 'Unused Email' Test to Address Jest Breaking Changes
112. Testing the Signin Flow
113. Refactor 'Invalid Password' Test to Address Jest Breaking Changes
114. Checking Password Comparison
115. More Intelligent Mocks
116. Refactor 3 Mocks to Address Jest Breaking Changes
117. Refactoring to Use Intelligent Mocks
118. Unit Testing a Controller
119. More Mock Implementations
120. Refactor 'User id is not found' Test to Address Jest Breaking Changes
121. Not Super Effective Tests
122. Testing the Signin Method
123. Integration Testing
124. Getting Started with End to End Testing
125. Creating an End to End Test
126. App Setup Issues in Spec Files
127. Applying a Globally Scoped Pipe
128. Applying a Globally Scoped Middleware
129. Solving Failures Around Repeat Test Runs
130. Creating Separate Test and Dev Databases
131. Managing App Configuration
132. Understanding Dotenv
133. Applying Dotenv for Config
134. Specifying the Runtime Environment
135. Solving a SQLite Error
136. It Works!
137. A Followup Test
138. Relations with TypeORM
139. Back to Reports
140. Adding Properties to Reports
141. A DTO for Report Creation
142. Receiving Report Creation Requests
143. Saving a Report with the Reports Service
144. Testing Report Creation
145. Building Associations
146. Types of Associations
147. The ManyToOne and OneToMany Decorators
148. Important Note About Deleting Database - Do Not Skip
149. More on Decorators
150. Setting up the Association
151. Formatting the Report Response
152. Transforming Properties with a DTO
153. A Basic Permissions System
154. Adding in Report Approval
155. Required Update for changeApproval Method
156. Testing Report Approval
157. Authorization vs Authentication
158. Adding an Authorization Guard
159. The Guard Doesn't Work?!
160. Middlewares, Guards, and Interceptors
161. Assigning CurrentUser with a Middleware
162. Fixing a Type Definition Error
163. Validating Query String Values
164. Transforming Query String Data
165. How Will We Generate an Estimate
166. Query Builders with TypeORM
167. Creating a Query Builder
168. Writing a Query to Produce the Estimate
169. Testing the Estimate Logic
170. Production Deployment
171. The Path to Production
172. Providing the Cookie Key
173. Understanding the Synchronize Flag
174. The Dangers of Synchronize
175. The Theory Behind Migrations
176. Headaches with Config Management
177. TypeORM and Nest Config is Great
178. Env-Specific Database Config
179. Installing the TypeORM CLI
180. Generating and Running Migrations
181. Required Migration Update for Production
182. Running Migrations During E2E Tests
183. Production DB Config
184. Heroku CLI Setup Instructions
185. Heroku Specific Project Config
186. Deploying the App - (Final Lecture)
187. [Bonus] Appendix: TypeScript
188. How to Get Help
189. TypeScript Overview
190. Environment Setup
191. Important Axios and TypeScript Version Information
192. A First App
193. Executing TypeScript Code
194. One Quick Change
195. Catching Errors with TypeScript
196. Catching More Errors!
197. Course Overview
198. Types
199. More on Types
200. Examples of Types

NestJS is a Node.js framework for building efficient, reliable, scalable server-side applications. Its structure is opinionated and draws inspiration from Angular. Nest has gained popularity; more than 3 million downloads on NPM weekly.

While I was learning NestJS, the learning curve was very steep. I wished there was a detailed and well-structured course that would make my learning path easy. That's why I came up with this course: so that other developers who are trying to learn NestJS do not have to go through such a steep learning curve.

I can assure you that the "NestJS Masterclass" is the most detailed, extensive, well-structured, and in-depth course in the marketplace—period! - There is no other course like NestJS Masterclass, Guaranteed!

NestJS Masterclass is a Practical Course!  We work together to build a REST API server-side application for a blog. We learn while we code this application, so all the examples in this course are real-world use cases. While programming this application, we will learn various NestJS features and dive deeper into the internal mechanics of NestJS.

Well-designed and Structured Curriculum

While designing the curriculum of the NestJS masterclass, I have spent a lot of time and effort thinking and ensuring that this makes learning NestJS easy for my students. Here is a partial list of topics covered in the NestJS Masterclass and what you can expect to learn from each section.  Refer to the curriculum section for a detailed list of all topics covered.

1. Understanding Modules: I introduce you to NestJS modules, how they work, the internal mechanics of how they are linked to each other, and various schematics that are used with modules, including services and providers.

2. Validation And Pipes: This is a crucial section that explains how you can leverage packages like class validator and Pipes in NestJS to validate the incoming data to your application.

3. Dependency Injection: Dependency injection is the backbone of the NestJS framework. We dive deeper into how it works and how to leverage it to ensure that your application remains modular. We work on all possible dependencies, including circular ones between modules.

4. Documenting Code: We learn about NestJS's features, which let you document the API endpoints using Open API Specification and your application's source code using Compodoc.

5. TypeORM and Relational Databases: TypeORM has a close integration with NestJS. We use PostgreSQL in the REST API application we build and learn how to leverage all features of TypeORM while building a real-world application.

6. Database Relations: This section teaches you about relationships in SQL databases and how to use TypeORM to set them. This includes one-to-one, one-to-many, and many-to-many relationships. It is a detailed and well-designed section that eliminates all misconceptions about database connections.

7. Configuration Environments In NestJS:  Applications often run in different environments. Depending on the environment, different configuration settings should be used. NestJS has a well-designed system for managing configurations.

8. Exception Handling: Elegantly handling exceptions within an application is crucial, as it improves the experience of developers and application users. We look at features NestJS provides that help us handle exceptions within an application.

9. Database Transactions: Database transactions are important when you want to perform CRUD operations, which impact multiple entities simultaneously and are interdependent. We dive deeper into TypeORM transactions to see how they can be used with NestJS. 

10. User Authentication with JSON Web Tokens: We work on building a user authentication system using JWTs and learn the mechanics behind a secure and well-designed System.

11. Guards and Decorators: Guards and Decorators are a few of the important schematics offered by NestJS. We use Guards to filter out unauthorized requests and decorators to set meta-data and attach payloads to incoming requests.

12. Google Authentication: Modern applications are interconnected and usually offer an easy signup process using services like Google OAuth. We use Google Authentication along with the JWTs Authentication service we create for the NestJS application we build.

13. File Uploads:  Most applications need a file upload mechanism for users to upload files to the server and use them later. We learn about NestJS Interceptors and how they can be used to upload files to NestJS.

14. Unit and End-to-End Testing: NestJS has been developed to keep the code you write modular so you can test it quickly. To live up to this practice, I have created dedicated modules for unit testing and end-to-end testing in NestJS for this course.

15. Mongoose and MongoDB: Many times, you need to use NoSQL databases like MongoDB with the NestJS application. We do exactly that in this section. So, no matter which database you want to use, NestJS Masterclass is a perfect fit.

16. Deployment to AWS: We examine all the intrinsic details of deploying a production application to AWS. We also explore using CloudFront CDN and S3 buckets to upload and serve media files for our application.

17. And lots more ...

Who am I?

I will give a quick introduction about myself I am Manik and I am a full stack developer and working as one since last fifteen years of my life.

Why did I choose to teach NestJS?

NestJS is a robust framework that is very close to my heart. For the last four years, I have been working on It. I have developed and maintained an application using NestJS, which has more than One Million Hits daily. I had a tough time learning NestJS due to the lack of tutorials, and that's why I decided to make this course so that I can teach what I have learned throughout all my years working with NestJS.

1. Introduction TO NestJS
2. NestJS Masterclass Introduction
3. What Will We Build in This Course
4. What is NestJS
5. Setting Up The Development Enviroment
6. Installing NestJS CLI
7. Creating Our First NestJs Application
8. Boilerplate Code In NestJs
9. Best Learning Path For The Course
10. Understanding Modules
11. What are Modules?
12. How NestJS Bootstraps (main.ts)
13. Understanding the app Module
14. Creating a New users Module
15. What is a REST API
16. Setting Up Postman and httpYac
17. Creating Controllers
18. Working With Routing Decorators
19. Params, Query and Body
20. Additional Request Components
21. Providers in NestJS
22. Validation And Pipes
23. What are Pipes?
24. Validation and Transformation Needs
25. Validating Params with Built-in Pipes
26. Validating Query Params
27. Introduction to DTO
28. Creating Our First DTO
29. Connecting DTO to Route Method
30. Global Pipes and Avoiding Malicious Request
31. Converting to an Instance of DTO
32. Using DTOs with Params
33. Using Mapped Types To Avoid Code Duplication
34. Dependency Injection
35. Introduction To Inversion Of Control
36. Dependency Injection In NestJS
37. Create a users Service
38. findall Users Method
39. findOneById Users Method
40. Practice: Create a Posts Module
41. Solution: Create a Posts Module
42. Types Of Dependencies
43. Create a GET Posts Route With DTO
44. Return Posts From Posts Service
45. Use Users Service Inside Posts Service
46. Practice: Create an Auth Module
47. Solution: Create an Auth Module
48. Circular Dependency
49. Documenting Code
50. Documentation With NestJS
51. Open API Specification
52. Enabling Swagger in NestJS
53. Adding Configuration Methods to Swagger
54. Documenting GET users
55. Practice: POST Endpoint and DTO For Posts Controller
56. Solution: POST Endpoint and DTO For Posts Controller
57. Adding Validations To CreatePostDto
58. Working With Nested DTOs
59. Testing Validation
60. Using Swagger For Documenting CreatePostDto
61. Mapped Types Using Swagger
62. Getting Started With Compodoc
63. Compodoc Coverage And JSDocs
64. Working With SQL Databases
65. Working with Databases In NestJS
66. What is an ORM?
67. Installing PostgreSQL Locally
68. Adding psql to PATH
69. Connecting NestJS to PostgreSQL
70. Using Async Configuration
71. Theoretical Understanding of the Repository Pattern
72. Creating Our First Entity - user.entity
73. Expanding Entity Definition
74. Creating First Repository
75. Practice: Creating Post Entity
76. Solution: Creating Post Entity
77. Database Relations
78. Relationships in SQL Database
79. Creating the Tags Entity
80. Creating The Meta Options Entity
81. Updating DTO Files
82. Autoloading Entities
83. One to One Relationships
84. Uni-directional One To One Relationship
85. Creating MetaOptions Service
86. Creating Post With Relationships
87. Cascade Creation with Relationships
88. Querying with Eager Loading
89. Deleting Related Entities
90. Bi-Directional One To One Relationship
91. Creating A Bi-Directional Relationship
92. Cascade Delete With Bi-Directional Relationship
93. One To Many Relationships
94. Creating One To Many Relationship
95. Create Post With Author
96. Eager Loading Author
97. Many To Many Relationships
98. Practice: Service To Create Tags
99. Solution: TagsService
100. Testing Tags Service
101. Uni-Directional Many To Many Relationship
102. Querying Many To Many Relationship
103. Updating Post With New Tags
104. Deleting Post and Relationship
105. Bi-Directional Many To Many Relationship
106. Cascade Delete With Many To Many
107. Soft Delete Tags
108. Environments In NestJS
109. Introduction To Environments
110. Installing Config Module
111. Using Config Service
112. Confirming NODE_ENV While Testing
113. Conditionally Loading Environments
114. Inject Database Details
115. Custom configuration Files
116. Config Files With Namespaces
117. Module Configuration and Partial Registration
118. Validating Environment Variables
119. Exception Handling
120. Introduction To Exception Handling
121. Built-in Http Exceptions
122. Identifying Points of Failure
123. Exception Handling Model Constraints
124. Create User Exception Handling
125. Throw a Custom Exception
126. Practice: Exception Handling Post Update
127. Solution: Exception Handling Post Update
128. Transactions Using TypeORM
129. Understanding Transactions
130. TypeORM QueryRunner
131. Creating First Transaction
132. Why Create Post Is Not a Transaction
133. Creating Multiple Providers
134. Updating The DTO
135. Practice: Handle Exceptions For CreateManyUsers
136. Solution: Handle Exceptions For CreateManyUsers
137. Pagination
138. Introduction To Pagination
139. Creating Pagination Query DTO
140. Adding Pagination To Query
141. Pagination Module And Interface
142. Using paginateQuery
143. Building Response Object
144. Complete Paginated Response
145. User Authentication
146. Introduction To Authentication
147. Hashing And Salting Passwords
148. Create Hashing Providers
149. Implementing Hashing Provider
150. User Signup
151. User SignIn Controller
152. Completing the signIn Method
153. Custom Response Code
154. Understanding JWTs
155. Adding JWT Configuration
156. Generating JWT
157. JWT Token Signatures
158. Guards and Decorators
159. Introducing Guards
160. Creating AccessTokenGuard
161. Completing AccessTokenGuard Implementation
162. Testing the AccessTokenGuard
163. Applying AccessTokenGuard Globally
164. Practice: Validations For JWT env Variables
165. Solution: Validations For JWT env Variables
166. What Are Decorators
167. Our First Decorator
168. Authentication Guard Strategy
169. Create AuthenticationGuard
170. AuthenticationGuard Implemenation
171. Understanding User Payload
172. Create Active User Decorator
173. Practice: Refactor createPostDto
174. Solution: Refactor createPostDto
175. Refresh Tokens
176. Introduction To Refresh Tokens
177. Refresh Token Configuration
178. Generate Tokens Provider
179. Generate Tokens Method
180. Generate Refresh Token On SignIn
181. Generate Access Token Using Refresh Token
182. Create Refresh Token Endpoint
183. Google Authentication
184. Google Authentication Strategy
185. Create Google Project
186. Setting The Configuration
187. Initialize Google Auth Client
188. Implementation Strategy Google Authentication
189. Implement Authentication With Google Token
190. React App In Front-End
191. createGoogleUser Method
192. Complete Google Authentication
193. Testing Google Authentication
194. Serialization And Interceptors
195. Introducing Interceptors and Serialization
196. Serializing User Entity
197. Global Data Interceptor
198. Adding API Version
199. File Uploads
200. Introduction To File Uploads

NestJS is an incredible backend framework that allows us to build scaleable Node.js backends with very little complexity. A microservice architecture is a popular architecture that allows us to build & deploy several independent applications that communicate with each other via a chosen transport layer.

This course is designed to bridge the gap between NestJS & this microservice architecture. It goes beyond the NestJS documentation to show you how to build a real reservation booking system that accepts payments, sends email notifications, and persists data to a MongoDB, Postgres & MySQL database.

Here are just some of the few additional things you can expect to learn in this course:

• Develop a productionized Dockerfile for NestJS microservices

• Create a monorepo & shared library for common code

• Learn how to create a custom package.json & Dockerfile for each microservice

• Automate the build & deployment of Dockerfiles with a custom CI/CD process

• Connect microservices together using a TCP transport layer

This course also includes full access to the GitHub repository so you have access to the completed project at all times & can reference this completed code. Additionally, you can post any issues or questions to the QA section & I will be happy to assist you.

By the end of this course, you will know how to build, deploy & test Nestjs Microservices so you can create any scaleable application that you can think of.

1. Introduction
2. Introduction
3. Course Outline
4. Course Prerequisites
5. System Architecture
6. Project Dependencies
7. GitHub Repository
8. Project Setup
9. Common Library
10. Database & Config Module
11. Abstract Repository
12. Reservations CRUD
13. Validation & Logging
14. Note for Windows
15. Dockerize
16. Authentication
17. Users
18. Passport
19. Local Strategy
20. JWT Strategy
21. Common Auth Guard
22. Payments
23. Stripe Setup
24. Reservations Payments - Part 1
25. Reservations Payments - Part 2
26. Notifications
27. Emit Notification
28. Email Notification
29. Production Deployment
30. Google Cloud Engine Setup
31. Productionize & Push Dockerfile
32. Docker Build Hanging
33. Automated CI/CD With CloudBuild
34. Helm Chart
35. MongoDB Atlas
36. Kubernetes Services & Env Variables - Part 1
37. Kubernetes Services & Env Variables - Part 2
38. Health Check
39. Google Cloud
40. Google Kubernetes Engine
41. Ingress Load Balancer
42. Amazon Web Services
43. AWS Branch
44. CI/CD With CodePipeline
45. Amazon Elastic Kubernetes Service (EKS)
46. E2E Tests
47. Health Checks
48. Create & Get Reservations
49. Extra
50. User Roles
51. Debugging
52. TypeORM & MySQL
53. Database Module
54. Abstract Repository
55. Entities
56. CRUD
57. RabbitMQ
58. Add RabbitMQ
59. Test & Compare RabbitMQ
60. gRPC
61. Additional Resources
62. Introduction
63. Protocol Buffers
64. Using TS Proto - Part 1
65. Using TS Proto - Part 2
66. GraphQL API Gateway
67. Apollo Federation
68. Apollo Federation Gateway
69. Reservations
70. Auth Contex & Playground
71. Auth Service & Payments
72. Prisma
73. Prisma
74. Postgres
75. Prisma Schema & Migrations
76. Reservations Prisma Refactor
77. Reservations Prisma Docker
78. Auth Prisma Refactor
79. Auth Prisma Docker
80. Prisma Wrap Up

This course will teach you how to build a modern Next.js app using the latest App directory approach. We will build a shopping app and learn all the core fundamentals of building a modern Next.js app. We will also connect the app to a NestJS backend and store data using Prisma ORM.

This architecture allows us to take advantage of the amazing performance & security features of Next.js with server-side rendering while still maintaining a clean scaleable backend using NestJS. By building a real working shopping app integrated with Stripe to accept payments we will go beyond the documentation & learn what it takes to build and deploy a full-stack web application to production.

Additionally, we will cover production deployment using AWS & Vercel to implement a continuous delivery pipeline and expose our application to the internet on a real working domain. This will ensure the app is automatically built & deployed with every commit without us having to do a thing.

The entire project will be protected with industry-standard JWT authentication so only authenticated users can access our application. We will utilize WebSockets to receive real-time updates from our backend whenever a new product is added or purchased. This will be facilitated with the usage of Stripe webhooks.

By the end of the course, we’ll have gone through the bulk of the Next.js documentation by building a real working app. You’ll be able to apply what you’ve learned to build your own modern full-stack app.

1. Introduction
2. Resources
3. Project Structure
4. Material UI
5. Auth Routes
6. NestJS Backend
7. Backend Setup
8. Users Module
9. Validation + Config + Logging
10. Prisma
11. Create User
12. Server Actions
13. Create User Server Action - Part 1
14. Create User Server Action - Part 2
15. Authentication
16. Local Strategy
17. Sign JWT
18. JWT Strategy
19. JSON Payloads
20. UI Login Auth
21. Server Cookies
22. UI Auth Middleware
23. Header
24. Header
25. Authentication Context
26. Logout & Navigation
27. Products
28. Products Schema
29. Create Products Backend
30. Create Product Modal
31. Create Product Server Action
32. Get Products
33. Products Cache
34. Image Upload
35. Product Upload Backend
36. Product Upload UI
37. Serve Static
38. Next.js Image
39. Single Product
40. Single Product Routing & Backend
41. Single Product UI
42. Stripe
43. Stripe Checkout Session
44. Stripe Checkout Redirect
45. Stripe Webhooks
46. Product WebSockets
47. Products Filter
48. Products Gateway
49. Products WebSockets
50. WebSocket Authentication
51. Production
52. Postgres Connection String
53. Elastic Beanstalk
54. Production Code
55. CodePipeline
56. Vercel
57. Custom Domain
58. Stripe & Images
59. S3 Public Bucket Policy
60. S3 Image Upload

Explore the dynamic universe of server-side web development with this meticulously crafted Nest.js course, tailored for both aspiring learners and seasoned professionals looking to master server-side TypeScript. This progressive guide takes you on a hands-on exploration of Nest.js, with a new generation development approach with typescript.

In this course, you’ll learn the correct approach to tackle real-world projects - ensuring that you gain practical skills that are directly applicable in professional settings.

Here are the key features of this course:

• NestJS Basics

• Controllers

• Pipes

• Guards

• Interceptors

• Middleware

• CRUD with MySQL

• TypeORM

• REST APIs

• Cookies

• Session

• JWT

• BcryptJS

• Working with MongoDB

• Mongoose

• Practical assignments & more...

Master NestJS Fundamentals → Grasp the foundational principles like Controllers, Pipes, Guards and Middleware

CRUD Operations with MySQL and MongoDB → Master techniques for building robust web applications and APIs with RDBMS and NoSQL databases.

Interceptors → Make use of interceptors that intercept incoming and outgoing requests in your application to modify request and response data, execute additional logic, or handle errors globally.

By the end of this course, you will be able to:

• Build scalable and maintainable Node.js applications

• Effectively use TypeScript in your NestJS projects

• Master the core concepts of NestJS architecture

• Create robust RESTful APIs

• Implement advanced features like middleware, pipes, interceptors, and guards

• Write comprehensive tests for your code

1. Introduction
2. Introduction to NEST JS
3. Setting up the project
4. Understanding Project Structure
5. Nest JS Fundamentals
6. Understanding Controllers
7. Controller Fundamentals(@Get Handler)
8. Controller Fundamentals(Headers)
9. Controller Fundamentals (@Post Handler)
10. Controller Fundamentals (@Post Handler) - Pt 2 with Modules
11. Controller Fundamentals (Fetching Params)
12. Controller Fundamentals (@Put Handler)
13. Controller Fundamentals (@Patch Handler)
14. Controller Fundamentals (@Delete Handler)
15. Request Object
16. Response Object
17. Fetching Queries
18. @HttpCode Vs. @Res Decorator
19. HTTP Response Status
20. Working with pipes
21. Introduction To Pipes
22. Built-in Pipes(ParseIntPipe)
23. Built-in Pipes(ParseFloatPipe)
24. Built-in Pipes(ParseBooleanPipe)
25. Built-in Pipes(ParseArrayPipe)
26. Built-in Pipes (ParseUUIDPipe)
27. Built-in Pipes (ValidationPipe)
28. Validating empty fields
29. Validating Field Length
30. Custom Validation Messages
31. Validating Field Using @IsEnum() Validator
32. Validating Dates In NestJS
33. Validating Optional Fields
34. Validating Regex Pattern
35. Creating A Custom Pipe
36. Understanding ArgumentMetadata (metadata.type)
37. Assignment - Custom Pipe (Handling different “type” arguments)
38. Understanding ArgumentMetadata (metadata.metatype)
39. Understanding ArgumentMetadata (metadata.data)
40. Implementing Global Pipes
41. NestJS Middleware
42. Introduction to Nest Middlewares
43. Implementing Middleware
44. Registering a Middleware
45. Route-Specific Middleware
46. Assignment - Checking Content-type With Middleware
47. Handling Route Wildcards
48. Middleware For Specific Route Handlers
49. Excluding Routes
50. Controller-Driven Route Middleware
51. Understanding Functional Middleware
52. Applying Multiple Middlewares
53. Applying Global Middlewares
54. Assignment - Password Encryption Middleware
55. NestJS Guards
56. Introduction To Guards
57. Understanding Guard
58. Understanding ExecutionContext
59. Accessing Arguments With getArgs()
60. Limiting Controller Access With Guard
61. Understanding switchToHttp() method
62. Assignment - API Key Authorization
63. Applying Multiple Guards
64. Defining Custom Metadata
65. Setting Custom Metadata - A Better Way
66. Applying Role For Specific Handlers
67. Applying Multiple Roles
68. Applying Global Guards
69. NestJS Interceptors
70. Introduction To Interceptors
71. Understanding Interceptor
72. Assignment - Transforming Response Data
73. Assignment - Modifying Request Headers
74. Assignment - Hiding Sensitive Information
75. Exception Mapping
76. Data Validation With Interceptor
77. Authentication and Authorization
78. Applying Global Interceptors
79. NestJS With MySQL
80. Connecting To MySQL Database Using TypeORM
81. Creating Entity With TypeORM
82. Inserting Product Data(CRUD)
83. Fetching the Product Data(CRUD)
84. Updating Product Record(CRUD)
85. Deleting Product Record(CRUD)
86. Practical Application - Creating a MyStore App
87. Introduction to MyStore Application
88. Rendering Template On Server
89. Creating Navbar With “includes”
90. Creating Home Interface
91. Conditional Rendering - No Product Found
92. Configuring Add Product Route
93. Creating “Add Product” Interface
94. Configuring Edit Product Route
95. Interface & Functionality - Edit Product
96. Attaching Templates to MySQL
97. Fetching The Products
98. Adding Product To Database - Part 1
99. Adding Product To Database - Part 2
100. Updating The Product
101. Deleting The Product
102. MyStore - Authentication/Session Cookie
103. Section Introduction
104. Setting Up The Sign-up Route
105. Designing the Sign-Up Form
106. Implementing Show/Hide Password Functionality
107. Validating Password
108. Registering User To The Database
109. Configuring Login Page
110. Validating User & Sending Cookie
111. Reading A Cookie
112. Rendering DOM Based On Login Status
113. Implementing Logout
114. Configuring Express-Session
115. Sending And Reading Session Cookie
116. Storing Sessions In MySQL
117. Destroying The Session - Logout
118. Optimizing Session Storage
119. Implementing JWT Token
120. Validating Request With Middleware
121. Conditional Rendering With Token
122. Hashing The Password On SignUp
123. Validating Login Credentials
124. Finalizing MyStore Application
125. NestJS With MongoDB & Mongoose
126. Connecting To MongoDB Database
127. Creating A Schema
128. Registering The Schema
129. Create & Save Product To MongoDB
130. Fetching Documents From MongoDB
131. Updating A Document In MongoDB
132. Deleting A Document From MongoDB
133. MyStore With MongoDB & Mongoose
134. Connecting MyStore With MongoDB Database
135. Creating User Schema
136. Injecting The User Schema
137. Creating Product Schema
138. Injecting The Product Schema
139. Creating MongoDB Session Store