Decorator-based architecture in NestJS - Step-by-Step Execution

Concept Flow - Decorator-based architecture

Define Class

↓

Apply Decorators

↓

NestJS Reads Metadata

↓

Build Dependency Graph

↓

Instantiate Classes with Injected Dependencies

↓

Run Application

This flow shows how NestJS uses decorators to mark classes and methods, reads metadata, builds dependencies, and runs the app.

Execution Sample

NestJS

import { Controller, Get } from '@nestjs/common';

@Controller('cats')
export class CatsController {
  @Get()
  findAll() { return 'All cats'; }
}

Defines a controller with a route using decorators to mark class and method for NestJS routing.

Execution Table

Step	Action	Decorator Processed	Metadata Added	Effect
1	Read @Controller('cats') on CatsController	@Controller	Route prefix 'cats' added	Class marked as controller with base route
2	Read @Get() on findAll method	@Get	Route GET '/' added	Method marked as GET handler
3	NestJS builds routing table	N/A	Controller and routes registered	App knows to call findAll on GET /cats
4	App starts and listens	N/A	Server running	Ready to handle requests
5	Request GET /cats received	N/A	Route matched	findAll method called
6	findAll returns 'All cats'	N/A	Response generated	Client receives 'All cats'
7	No more requests	N/A	Idle	Waiting for next request

💡 Execution stops when no more requests are received or app is stopped.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 5	Final
CatsController Metadata	{}	{ routePrefix: 'cats' }	{ routePrefix: 'cats', routes: [{ method: 'GET', path: '/' }] }	{ registered: true }	{ registered: true, lastCall: 'findAll' }	{ registered: true, lastCall: 'findAll', response: 'All cats' }

Key Moments - 3 Insights

Why does NestJS use decorators instead of normal functions?

Decorators add metadata to classes and methods that NestJS reads later to build routing and dependency injection, as shown in steps 1 and 2 of the execution_table.

How does NestJS know which method to call for a GET request?

The @Get decorator adds route info to the method metadata (step 2), which NestJS uses to match incoming requests to methods (step 5).

What happens if no decorator is used on a class?

Without decorators, NestJS does not register the class as a controller or provider, so it won't be part of the app's routing or dependency graph.

Visual Quiz - 3 Questions

Look at the execution_table, what metadata is added after step 2?

A Server starts listening

B Route prefix 'cats' added to CatsController

C Route GET '/' added to findAll method

D Response 'All cats' generated

💡 Hint

Check the 'Metadata Added' column in row 2 of execution_table

At which step does NestJS register the controller and routes?

A Step 3

B Step 1

C Step 5

D Step 7

💡 Hint

Look for 'registered' status in the 'Effect' column in execution_table

If the @Get decorator is removed, what changes in the execution_table?

A Step 1 would fail to add route prefix

B Step 2 metadata would be missing, no GET route registered

C App would not start at step 4

D Response would still be 'All cats'

💡 Hint

Refer to step 2 where @Get adds route metadata

Concept Snapshot

Decorator-based architecture in NestJS:
- Use decorators like @Controller and @Get to mark classes and methods
- Decorators add metadata NestJS reads to build routing and DI
- NestJS creates instances and routes requests based on metadata
- This pattern keeps code clean and declarative
- Removing decorators means NestJS ignores those classes/methods

Full Transcript

In NestJS, decorators are special markers on classes and methods. When the app starts, NestJS reads these decorators to understand which classes are controllers and which methods handle routes. For example, @Controller('cats') marks a class as a controller with a base route 'cats'. The @Get decorator on a method marks it as a handler for GET requests. NestJS collects this metadata, builds a routing table, and when a request comes in, it calls the right method. This flow lets developers write clean code while NestJS handles wiring everything together.