Made withNestJSClip

Every NestJS Concept Explained in 9 Minutes

T

Tech Vision

Creator on the NestJS channel

Watch on YouTube ↗

216K viewsJul 8, 20249:19 runtime

Master the NestJS framework by understanding its 10 core concepts. This guide explains how to build different types of applications, including HTTP servers, microservices, and standalone apps. Learn about the fundamental building blocks like modules, controllers, and providers…

Chapters

#nestjs#clip#backend

Core Philosophy

Understanding the fundamental concepts of a framework like NestJS is more powerful than memorizing specific code implementations. This knowledge allows you to diagnose problems, find information, and design better features.

1. Application Types

NestJS is a platform-agnostic framework capable of creating more than just REST APIs.

HTTP Servers: Standard web servers and APIs, created with NestFactory.create().
Microservices: Services communicating over different transport protocols (e.g., TCP, NATS) on an internal network, created with NestFactory.createMicroservice().
Standalone Applications: Applications without network listeners, ideal for CRON jobs or CLI tools, created with NestFactory.createApplicationContext().

Important
All NestJS applications, regardless of type, require a root module to start.

2. Modules (`@Module`)

Modules are the fundamental building blocks for structuring a NestJS application.

They are TypeScript classes decorated with @Module().
An application is a graph of modules, starting from the AppModule (the root module).
Modules encapsulate a set of related capabilities (e.g., controllers, providers).
Relationships are defined in the @Module decorator's imports array.

3. Decorators

Decorators are a special kind of function used extensively in NestJS to add metadata and modify the behavior of classes, methods, or properties.

@Module(): Defines a module.
@Controller(): Defines a controller.
@Injectable(): Defines a provider that can be managed by the NestJS IoC container.
@Get(), @Post(), etc.: Define HTTP route handlers.

4. Controllers (`@Controller`)

Controllers are responsible for handling incoming requests and returning responses to the client.

They are classes decorated with @Controller(), which can take a base path prefix (e.g., @Controller('users')).
Methods within a controller are decorated with HTTP method decorators (e.g., @Get(':id')) to define specific endpoints.

Tip
A controller's primary role is to manage request/response flow. Complex business logic should be delegated to providers (services).

5. Providers (`@Injectable`) & Dependency Injection

Providers are a fundamental concept in NestJS, encompassing services, repositories, factories, helpers, etc.

A provider is a class decorated with @Injectable().
They can be injected into other classes (like controllers or other providers) through their constructors. NestJS automatically resolves and injects these dependencies.
This pattern is called Dependency Injection (DI), which promotes decoupling and testability.
Providers are singletons by default, meaning NestJS creates a single instance and shares it across the application.

6. Request Lifecycle Hooks

NestJS provides a sequence of hooks to process requests. The typical order is: Middleware -> Guards -> Interceptors -> Pipes -> Route Handler.

Middleware

Executes before the route handler.
Ideal for tasks like logging, handling CORS, or parsing raw request bodies.
Similar to Express middleware.

Guards (`@Guard`)

Determine if a request should be handled.
Their main purpose is authorization (e.g., checking roles or permissions).
A guard must return true to allow the request to proceed or false (or throw an exception) to deny it.

Interceptors (`@Interceptor`)

Bind extra logic before and after the route handler executes.
Useful for transforming the result from a handler, caching responses, or logging request/response details.
They have access to both the request context and the response stream.

Pipes (`@Pipe`)

Operate on the arguments before they are passed to the route handler.
Have two main use cases:
1. Transformation: Convert data from one type to another (e.g., string to number).
2. Validation: Ensure input data conforms to specific rules.
NestJS includes built-in pipes like ValidationPipe, ParseIntPipe, and ParseUUIDPipe.

7. Exception Filters (`@Catch`)

Exception filters provide a way to process unhandled exceptions across your application and craft a custom response.

They are classes decorated with @Catch(), which can be scoped to a specific exception type or catch all exceptions.
This allows for a centralized and consistent error handling strategy, improving security and the client experience.

Note
By default, an unhandled exception results in a 500 Internal Server Error response. Custom filters allow you to return more meaningful status codes and messages.

Why Understanding Core Concepts Matters

I know exactly which button to press on my microwave to heat up my food, but if it breaks, I wouldn't be able to fix it. So the same goes for programming. So have you ever wondered how some people seem to always know how to fix the code, where to find the relevant information, and how to best implement new features?

They don't actually know everything. They just understand the key concepts and principles that allow them to navigate any piece of code they encounter. And after countless hours of going through the NestJS documentation, I've condensed the entire framework into 10 core concepts. And by the end of this video, I'm fairly confident that you too will be able to understand any NestJS code you encounter.

Concept 1: NestJS Application Types

The first concept is not often talked about, but it's actually a key to understand what NestJS is and what you can build with it. So there is a misconception that NestJS is only for building APIs, but in fact, there are three types of applications you can build with Nest. You can create HTTP servers using the NestFactory.create and request endpoints and effectively create APIs and web servers.

But you can also create microservices applications using NestFactory.createMicroservice. And microservices are very similar to HTTP servers, except that they can use different transport protocols such as TCP or NATS, and they can communicate via an internal network. And last but not least, you can also create standalone applications using NestFactory.createApplicationContext. And a standalone application is just an application that doesn't have network listeners, so they are great for creating scheduled tasks or creating CLI tools, even if you want. But they all have one thing in common: they need a root module.

Concept 2: Modules as Building Blocks

So let's talk about modules now. Modules are the building blocks of a Nest application. So you can picture a Nest app as a graph made of modules, and at the top, you always have a root module. And that root module can use other modules, and those modules can themselves use other modules, and so on.

For example, you could have an application with a product module, an order module that uses a cart and payment module, and they could all be using a shared configuration module. In terms of the implementation, a module is a class that is annotated with a @Module decorator.

Concept 3: The Power of Decorators

You absolutely need to understand the concept of decorators because they are everywhere in NestJS. Decorators can be a bit strange to start with, but once you understand what they are, it all clicks and you can do really powerful things. So a decorator is a special kind of function and it can be attached to methods, classes, properties, and it modifies their behavior and it can even add metadata.

Think of decorators as wearing accessories or suits that give you extra power. For example, you can take an empty naked class and dress it with a fancy shiny @Module decorator suit, and that means that it can be used by other classes that are wearing the same shiny @Module decorator suit. To create the application module graph, you define relationships between modules by passing an object property to the module decorators, and you define the related modules in the imports property. And once you have modules, you can add controllers inside them.

Concept 4: Controllers for Request Handling

Controllers are classes that are annotated with the @Controller decorator, so let's say that they are wearing a blue jacket. So a controller is simply in charge of receiving incoming requests and returning a response. So you can define a root path in the @Controller decorator, and you add methods to handle the incoming request. And those methods can be annotated with an HTTP verb, and those decorators can take a sub-route as a parameter. So the main role of the controller is to receive a request and return a response. Anything else is delegated to other classes.

Concept 5: Providers & Dependency Injection

Most of the code that you will be writing in Nest is within providers. So a provider is simply a class that can be injected in other classes as a dependency. So let's take a user service class as an example. So you annotate that class with the @Injectable decorator to indicate that it's a provider. Then you declare it as a provider in the user's module, and now you can inject it in the controller via the constructor.

So you can think of providers as freelance workers and NestJS is an agency that places those freelance workers wherever they are needed. And congratulation, you've used dependency injection and the Singleton pattern.

Concept 6: Middleware for Pre-processing

Now let me show you how to take full control of the request handling flow, starting with middleware. When you want to take a plane, you don't just park on the tarmac and enter the plane. So you have to go to check in your luggage, then you go through security, then you might even go through border control, then you show your boarding pass, and finally you get on the plane.

So just like a plane passenger, you can make a request go through several stages before it's handed over to the method handler. So for example, you could use middleware to log every incoming request. But don't start adding middlewares everywhere because I'll show you in the next concept that Nest comes with built-in features for common request flow management.

Concept 7: Guards for Authorization

Guards are a critical part of the request life cycle in NestJS. So they work more or less like a security check at an airport and their primary purpose is to determine whether the request will be handled by the route handler based on specific conditions like roles, permissions, or any custom logic.

So they have access to the execution context, and that allows them to inspect some details about the request. For example, an authentication guard can check if the user is authenticated and authorized to access a requested resource. And if the guard returns true, then the request passes through, and if it returns false, then the request is denied and we send an error response to the client.

Concept 8: Interceptors for Request/Response Manipulation

For example, after the guard you can add interceptors to your application. So they run before and after the root handler. So they give you full control over the request-response cycle. So interceptors implement the NestInterceptor interface and they can perform tasks like logging or caching. For example, an interceptor can log request details or map the response and input data format.

Concept 9: Pipes for Validation and Transformation

The next step before getting to the handler is pipes. So that's where you can validate and transform the data that is handled to the handler to ensure that it meets certain criteria or is in the correct format. So pipes are classes that implement the PipeTransform interface and they are annotated with the @Injectable decorator.

So for instance, a pipe can validate the data sent in a request to ensure that it conforms with the expected format or the expected type or certain constraints. It's up to you to implement whatever validation rules you want. But if the data is invalid, then the pipe can throw an exception, preventing the root handler from executing. Additionally, pipes can transform the data into a more suitable format for processing. For example, a pipe can convert a string input into an integer or parse dates from string representations.

Concept 10: Exception Filters for Error Handling

So built-in pipes like ValidationPipe, ParseIntPipe, and ParseUUIDPipe offer some common validation and transformation, but you can also create custom pipes to handle specific requirements. If at any point during the request handling, there is an unhandled error, NestJS would return a 500 internal error by default. But you can manually throw standard HTTP exceptions as well and be a bit more descriptive. And you can even customize error handling through exception filters.

Exception filters are classes that implement the ExceptionFilter interface and they are decorated with the @Catch decorator. They can catch exceptions thrown by any part of the request handling process, including guards, interceptors, pipes, or root handlers, of course. But when an exception is caught, the filter determines how to handle it and what response to send. For example, you can have like a global exception filter that can catch all exceptions, log the error details, and return a standard error response to the client. So this ensures that the client receives consistent error messages and that sensitive information is not exposed, and that will make front-end developers very happy as well. So exception filters provide a centralized way of handling errors and maintain the stability and security of your application.

Conclusion: Applying Your Knowledge

Everything that I've just shown you needs to be applied if you want these concepts to stick. You can watch this next video and apply those concepts, and you can follow along as I build a podcast API from scratch. And in that video, I'll also show you how to test your app.