NestJS Masterclass - NodeJS Framework Backend Development
Nest JS with Node and TypeScript to build REST APIs Backend with TypeORM, PostgreSQL, MongoDB, testing, AWS deployment.
Nest JS with Node and TypeScript to build REST APIs Backend with TypeORM, PostgreSQL, MongoDB, testing, AWS deployment.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Khu vực Câu hỏi thường gặp trống
What are Modules?
How NestJS Bootstraps (main.ts)
Understanding the app Module
Xem trướcCreating a New users Module
Xem trướcWhat is a REST API
Setting Up Postman and httpYac
Creating Controllers
Working With Routing Decorators
Params, Query and Body
Additional Request Components
Providers in NestJS
What are Pipes?
Validation and Transformation Needs
Validating Params with Built-in Pipes
Validating Query Params
Introduction to DTO
Creating Our First DTO
Connecting DTO to Route Method
Global Pipes and Avoiding Malicious Request
Converting to an Instance of DTO
Using DTOs with Params
Using Mapped Types To Avoid Code Duplication
Introduction To Inversion Of Control
Dependency Injection In NestJS
Create a users Service
Findall Users Method
FindOneById Users Method
Practice: Create a Posts Module
Solution: Create a Posts Module
Types Of Dependencies
Create a GET Posts Route With DTO
Return Posts From Posts Service
Use Users Service Inside Posts Service
Xem trướcPractice: Create an Auth Module
Solution: Create an Auth Module
Circular Dependency
Documentation With NestJS
Open API Specification
Enabling Swagger in NestJS
Adding Configuration Methods to Swagger
Documenting GET users
Practice: POST Endpoint and DTO For Posts Controller
Solution: POST Endpoint and DTO For Posts Controller
Adding Validations To CreatePostDto
Working With Nested DTOs
Testing Validation
Using Swagger For Documenting CreatePostDto
Mapped Types Using Swagger
Getting Started With Compodoc
Compodoc Coverage And JSDocs
Working with Databases In NestJS
What is an ORM?
Installing PostgreSQL Locally
Adding psql to PATH
Connecting NestJS to PostgreSQL
Using Async Configuration
Theoretical Understanding of the Repository Pattern
Creating Our First Entity - user.entity
Expanding Entity Definition
Creating First Repository
Practice: Creating Post Entity
Solution: Creating Post Entity
Relationships in SQL Database
Creating the Tags Entity
Creating The Meta Options Entity
Updating DTO Files
Autoloading Entities
One to One Relationships
Uni-directional One To One Relationship
Creating MetaOptions Service
Creating Post With Relationships
Cascade Creation with Relationships
Querying with Eager Loading
Deleting Related Entities
Bi-Directional One To One Relationship
Creating A Bi-Directional Relationship
Cascade Delete With Bi-Directional Relationship
One To Many Relationships
Creating One To Many Relationship
Create Post With Author
Eager Loading Author
Many To Many Relationships
Practice: Service To Create Tags
Solution: TagsService
Testing Tags Service
Uni-Directional Many To Many Relationship
Querying Many To Many Relationship
Updating Post With New Tags
Deleting Post and Relationship
Bi-Directional Many To Many Relationship
Cascade Delete With Many To Many
Soft Delete Tags
Introduction To Environments
Installing Config Module
Using Config Service
Confirming NODE_ENV While Testing
Conditionally Loading Environments
Inject Database Details
Custom configuration Files
Config Files With Namespaces
Module Configuration and Partial Registration
Validating Environment Variables
Introducing Guards
Creating AccessTokenGuard
Completing AccessTokenGuard Implementation
Testing the AccessTokenGuard
Applying AccessTokenGuard Globally
Practice: Validations For JWT env Variables
Solution: Validations For JWT env Variables
What Are Decorators
Our First Decorator
Authentication Guard Strategy
Create AuthenticationGuard
AuthenticationGuard Implemenation
Understanding User Payload
Create Active User Decorator
Practice: Refactor createPostDto
Solution: Refactor createPostDto
Google Authentication Strategy
Create Google Project
Setting The Configuration
Initialize Google Auth Client
Implementation Strategy Google Authentication
Implement Authentication With Google Token
React App In Front-End
CreateGoogleUser Method
Complete Google Authentication
Testing Google Authentication
Introduction To MongoDB With Mongoose
Creating MongoDB Account
MongoDB Configuration
First Schema - User
Post Schema
Create Using Model
Mongoose Sub Documents
Single Sub Document
Practice: Tags Module
Solution: Tags Module
Practice: Tags Service + Controller
Solution: Tags Service + Controller
Array Of Sub Documents
Querying Sub Documents
Having Basic Understanding of TypeScript and/or JavaScript.
Learn all the Schematics of a NestJS application. Become Familiar With NestJS Framework and all its components.
User Authentication using JSON Web Tokens and Google Authentication. Includes refresh tokens and security best practices.
Deploy the production application to AWS cloud with Cloudfront and S3 for media files.
Learn NestJS dependency injection in detail and understand the mechanics behind in.
Work With TypeORM and PostgreSQL. Deep dive into database relations, transactions, migrations and querying with TypeORM.
Request data validation using pipes in NestJS and Serialization of response data using Interceptors.
Deep dive into NestJS Guards to filter out requests and custom Decorators to add meta data modify request payload
Detailed and in-depth coverage of Environments and Configuration in a NestJS application with validation of Environment Variables.
Document the REST API endpoints with Open API Specifications and Swagger.
Using Compodoc for documenting the code and keeping the codebase organised for large teams.
Leverage testing in NestJS by writing Unit Test as well as End To End test for your application.
Use MongoDb along with Mongoose to create data schema and save date in MongoDB using NestJS.
Learn How to upload files using NestJS and save media files on Amazon S3 to serve using Cloudfront CDN
Understand complete NestJS request and response lifecycle along with the role of each schematics.
Learn how to design and develop REST APIs using industry standards and best practices
1 Học viên
8 Khóa học
0 Đánh giá