First NestJS application - Deep Dive

Overview - First NestJS application

What is it?

NestJS is a framework for building server-side applications using Node.js and TypeScript. It helps organize your code into modules, controllers, and services to keep things clean and easy to manage. A first NestJS application is a simple project that shows how to set up this structure and respond to web requests. It uses modern JavaScript features and patterns to make backend development easier.

Why it matters

Without NestJS, building a backend can become messy and hard to maintain as your app grows. NestJS solves this by giving you a clear way to organize code and handle requests, making your app more reliable and easier to update. This means faster development, fewer bugs, and better teamwork. Without it, developers might waste time fixing confusing code instead of adding features.

Where it fits

Before learning NestJS, you should know basic JavaScript or TypeScript and understand how web servers work. After mastering your first NestJS app, you can learn about advanced topics like database integration, authentication, and microservices with NestJS.

Mental Model

Core Idea

NestJS organizes backend code into clear parts that handle requests, business logic, and data, making server apps easy to build and maintain.

Think of it like...

Think of NestJS like a restaurant kitchen where each chef has a clear role: one takes orders (controller), another cooks the food (service), and the kitchen is organized into sections (modules) so everything runs smoothly.

┌─────────────┐       ┌─────────────┐       ┌─────────────┐
│   Module    │──────▶│ Controller  │──────▶│   Service   │
│ (Organizes) │       │ (Handles    │       │ (Does the   │
│             │       │  requests)  │       │  work)      │
└─────────────┘       └─────────────┘       └─────────────┘

Build-Up - 7 Steps

1

Foundation

Setting up NestJS project

Concept: Learn how to create a new NestJS project using the CLI tool.

Install Node.js and npm. Then install NestJS CLI globally with 'npm i -g @nestjs/cli'. Run 'nest new project-name' to create a new project folder with starter files. This sets up TypeScript, configuration, and basic structure automatically.

Result

A new folder with a ready-to-run NestJS app including main.ts, app.module.ts, and app.controller.ts.

Understanding how the CLI scaffolds your project saves time and ensures you start with a correct, working setup.

2

Foundation

Understanding main.ts entry point

Concept: Learn what main.ts does as the app's starting point.

main.ts is the file that starts the NestJS app. It creates an application instance from AppModule and tells it to listen on a port (usually 3000). This is like turning on the server so it can accept requests.

Result

The server starts and listens for incoming HTTP requests.

Knowing main.ts role helps you understand how your app boots and where to add global settings.

3

Intermediate

Creating a simple controller

🤔Before reading on: do you think a controller handles data storage or just incoming requests? Commit to your answer.

Concept: Controllers handle incoming requests and send responses.

In NestJS, a controller is a class decorated with @Controller. Inside, methods decorated with @Get, @Post, etc., respond to HTTP requests. For example, a method with @Get('/') returns a welcome message when the root URL is visited.

Result

Visiting http://localhost:3000/ shows the message returned by the controller method.

Understanding controllers as the app's front door clarifies how requests flow into your app.

4

Intermediate

Adding a service for logic

🤔Before reading on: do you think controllers should contain business logic or just call other parts? Commit to your answer.

Concept: Services hold business logic and are called by controllers.

Create a service class decorated with @Injectable. Put logic like returning data or calculations here. Inject this service into the controller via the constructor. The controller calls service methods to get data to send back.

Result

The controller returns data from the service, keeping code organized and reusable.

Separating logic into services keeps controllers simple and makes your code easier to test and maintain.

5

Intermediate

Using modules to organize code

Concept: Modules group related controllers and services.

AppModule is the root module decorated with @Module. It lists controllers and providers (services). You can create feature modules to organize parts of your app. Modules help NestJS know what parts belong together and manage dependencies.

Result

Your app structure becomes clear and scalable as you add more features.

Modules act like folders for your code, helping NestJS manage and load parts efficiently.

6

Advanced

Running and testing the app

🤔Before reading on: do you think 'npm run start' runs the app in development mode or production? Commit to your answer.

Concept: Learn how to run and test your NestJS app locally.

Use 'npm run start' to run the app normally. Use 'npm run start:dev' to run with auto-reload on code changes. Open a browser and visit http://localhost:3000 to see your app's response. Use tools like Postman or curl to test endpoints.

Result

You see your app respond to requests and can quickly test changes.

Knowing how to run and test your app efficiently speeds up development and debugging.

7

Expert

Understanding dependency injection

🤔Before reading on: do you think NestJS creates service instances manually or uses a system to manage them? Commit to your answer.

Concept: NestJS uses dependency injection to provide services to controllers automatically.

NestJS has a built-in container that creates and manages instances of services. When a controller needs a service, NestJS injects it via the constructor. This means you don't create service objects yourself; NestJS handles lifecycle and sharing.

Result

Your app has loosely coupled parts that are easier to test and maintain.

Understanding dependency injection reveals how NestJS manages complexity behind the scenes and why your code stays clean.

Under the Hood

NestJS uses TypeScript decorators to mark classes as modules, controllers, or services. At runtime, it builds a dependency injection container that creates and shares instances of services. When a request comes in, the framework routes it to the correct controller method based on metadata. The controller calls services injected by the container to handle logic and return responses. This layered approach separates concerns and manages object lifecycles automatically.

Why designed this way?

NestJS was designed to bring structure and scalability to Node.js backend development by borrowing ideas from Angular. It uses decorators and dependency injection to reduce boilerplate and improve testability. Alternatives like plain Express.js lack this organization, making large apps harder to maintain. NestJS balances flexibility with convention to speed up development without locking you in.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│  HTTP Request │──────▶│  Router (Nest)│──────▶│ Controller    │
│               │       │  matches path │       │ (handles req) │
└───────────────┘       └───────────────┘       └──────┬────────┘
                                                      │
                                                      ▼
                                             ┌────────────────┐
                                             │ Dependency     │
                                             │ Injection      │
                                             │ Container      │
                                             └──────┬─────────┘
                                                    │
                                                    ▼
                                             ┌───────────────┐
                                             │ Service       │
                                             │ (business     │
                                             │ logic)        │
                                             └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does NestJS force you to use Angular on the frontend? Commit yes or no.

Common Belief: Many think NestJS requires Angular because they share similar patterns.

Reality: NestJS is a backend framework and works independently of frontend frameworks. You can use any frontend or none at all.

Why it matters: Believing this limits your choice of frontend tools and can cause confusion about NestJS's role.

Quick: Do you think controllers should contain all your app's logic? Commit yes or no.

Common Belief: Some believe putting all logic in controllers is simpler and faster.

Reality: Controllers should only handle requests and delegate logic to services for clarity and testability.

Why it matters: Mixing logic in controllers leads to messy code that's hard to maintain and test.

Quick: Does NestJS automatically create a new service instance for every request? Commit yes or no.

Common Belief: People often think services are recreated on each request.

Reality: By default, services are singletons shared across requests unless scoped differently.

Why it matters: Misunderstanding this can cause bugs when assuming fresh state or trying to manage service lifecycles manually.

Quick: Is NestJS just a wrapper around Express.js with no added value? Commit yes or no.

Common Belief: Some think NestJS only adds complexity over Express without benefits.

Reality: NestJS adds structure, dependency injection, and modularity that Express lacks, improving maintainability.

Why it matters: Underestimating NestJS's design can lead to missing out on productivity and code quality improvements.

Expert Zone

1

Services in NestJS are singletons by default, but you can change their scope to request or transient for special cases.

2

Modules can import other modules to share providers, enabling flexible and scalable app architecture.

3

The dependency injection container supports custom providers and lifecycle hooks, allowing advanced control over service creation.

When NOT to use

NestJS is not ideal for very small or simple APIs where the overhead of its structure is unnecessary. In such cases, lightweight frameworks like Express or Fastify might be better. Also, if you need extreme performance tuning at low level, NestJS's abstraction might add overhead.

Production Patterns

In production, NestJS apps often use feature modules to separate concerns, global modules for shared services, and middleware for cross-cutting concerns like logging or authentication. Dependency injection enables easy mocking for tests. Many use NestJS with TypeORM or Prisma for database access and Passport for authentication.

Connections

Angular framework

NestJS borrows architectural patterns and dependency injection concepts from Angular.

Understanding Angular's modular and injectable design helps grasp NestJS's structure and why it feels familiar.

Dependency Injection (general software pattern)

NestJS implements dependency injection to manage object creation and dependencies.

Knowing the general pattern of dependency injection clarifies how NestJS keeps code loosely coupled and testable.

Restaurant kitchen workflow

Both organize roles and tasks clearly to handle orders efficiently.

Seeing NestJS as a kitchen with chefs for different jobs helps understand how controllers, services, and modules collaborate.

Common Pitfalls

#1 Putting business logic directly inside controller methods.

Wrong approach:

@Controller()
export class AppController {
@Get()
getData() {
// complex logic here
return computeSomething();
}
}

Correct approach:

@Injectable()
export class AppService {
computeSomething() {
// complex logic here
return result;
}
}

@Controller()
export class AppController {
constructor(private readonly appService: AppService) {}

@Get()
getData() {
return this.appService.computeSomething();
}
}

Root cause:

Confusing the role of controllers and services leads to mixing concerns and harder-to-maintain code.

#2 Not installing NestJS CLI and trying to set up project manually.

Wrong approach:

mkdir myapp
cd myapp
npm init -y
// manually create files without CLI scaffolding

Correct approach:

npm i -g @nestjs/cli
nest new myapp

Root cause:

Not using the CLI causes setup errors and wastes time configuring boilerplate.

#3 Forgetting to add services to module providers array.

Wrong approach:

@Module({
controllers: [AppController],
// providers missing AppService
})
export class AppModule {}

Correct approach:

@Module({
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}

Root cause:

Not registering providers means NestJS can't inject them, causing runtime errors.

Key Takeaways

NestJS structures backend apps into modules, controllers, and services to keep code organized and maintainable.

Controllers handle incoming requests and delegate work to services, which contain business logic.

The NestJS CLI tool quickly sets up a working project with best practices built-in.

Dependency injection in NestJS automatically manages service instances, making code loosely coupled and testable.

Understanding NestJS's architecture helps build scalable and clean server applications efficiently.