Welcome to the Empire! Introduction to NestJS

Salve, young legionary! Welcome to the Roman technology system! I am Consul Caesar.js, and you will become my young legionary in a campaign through the vast provinces of NestJS - the most powerful Node.js framework in the Internet Empire!

Just as the Roman Empire needs solid construction, an experienced legion, and well-organized cohorts, a NestJS application requires well-thought-out architecture, modularity, and a professional approach to building scalable server-side applications.

What is NestJS?

NestJS is a progressive Node.js framework for building efficient and scalable server-side applications. It was built in TypeScript and leverages the best patterns from the JavaScript ecosystem, combining them with powerful decorators and a dependency injection system known from Angular.

Imagine that NestJS is our mighty Roman Empire:

1// Our Roman cohorts (modules)
2import { Module } from '@nestjs/common';
3import { LegionModule } from './legion/legion.module';
4import { TributesModule } from './tributes/tributes.module';
5import { ForumModule } from './forum/forum.module';
6
7@Module({
8 imports: [LegionModule, TributesModule, ForumModule],
9})
10export class ImperiumModule {}

Fundamentals of NestJS

1. Decorators - our Roman rank insignia

In NestJS, decorators are like Roman rank insignia - they mark the rank and function of each element of the legion:

1// The Consul controls the entire operation
2@Controller('consul')
3export class ConsulController {
4
5 // Handles orders regarding tributes
6 @Get('tributes')
7 findTributes() {
8 return 'Imperial tributes from all provinces!';
9 }
10
11 // Recruits new legionaries
12 @Post('legion')
13 recruitLegionary(@Body() newLegionary: CreateLegionaryDto) {
14 return 'New legionary recruited successfully!';
15 }
16}

2. Modules - structures of our Empire

Each module is a separate structure of the Empire with a specific purpose:

1// Structure responsible for the legion
2@Module({
3 controllers: [LegionController],
4 providers: [LegionService],
5 exports: [LegionService],
6})
7export class LegionModule {}
8
9// Structure responsible for tributes
10@Module({
11 controllers: [TributesController],
12 providers: [TributesService],
13 imports: [DatabaseModule],
14})
15export class TributesModule {}

3. Dependency Injection - the chain of command

The DI system in NestJS is like the hierarchy in a Roman legion - everyone knows who to take orders from:

1@Injectable()
2export class TributesService {
3 constructor(
4 private readonly mapService: MapService,
5 private readonly collectorService: CollectorService,
6 ) {}
7
8 async findTributes(province: string) {
9 const location = await this.mapService.getProvince(province);
10 return this.collectorService.collect(location);
11 }
12}

Installation and first steps

To begin our campaign in the Empire, you need the proper equipment:

1# Install NestJS CLI - our engineering tools
2npm install -g @nestjs/cli
3
4# Create a new Empire (project)
5nest new roman-imperium
6
7# Enter the system
8cd roman-imperium
9
10# Raise the legion standards (start the server)
11npm run start:dev

Structure of the Roman Empire (project)

1roman-imperium/
2├── src/
3│ ├── main.ts # Forum Romanum - entry point
4│ ├── app.module.ts # The Main Senate
5│ ├── app.controller.ts # Consul - main controller
6│ ├── app.service.ts # Primus Centurion
7│ ├── legion/ # Legion structure
8│ │ ├── legion.module.ts
9│ │ ├── legion.controller.ts
10│ │ └── legion.service.ts
11│ ├── tributes/ # Tributes structure
12│ └── forum/ # Forum structure
13├── test/ # Training grounds
14├── package.json # Imperial registry
15└── nest-cli.json # Engineering instructions

First endpoint - imperial signal

Let's create our first endpoint that will signal the presence of the Empire:

1// app.controller.ts
2import { Controller, Get } from '@nestjs/common';
3import { AppService } from './app.service';
4
5@Controller()
6export class AppController {
7 constructor(private readonly appService: AppService) {}
8
9 @Get()
10 getSignal(): string {
11 return '⚔️ Roman Imperium is ready for campaign!';
12 }
13
14 @Get('status')
15 getImperiumStatus() {
16 return {
17 legion: 'Ready for campaign',
18 tributes: 'Collecting...',
19 destination: 'New provinces',
20 consul: 'Caesar.js at your service!'
21 };
22 }
23}

Advantages of NestJS for the Empire

1. Modularity - each structure of the Empire has its own task
2. TypeScript - precision like Roman engineering
3. Decorators - readable markings like legion signals
4. Testing - we check everything before setting out on a campaign
5. Documentation - automatic maps of our provinces (Swagger)
6. Scalability - from a small castrum to Empire architecture

Practical exercise

Time for the first imperial test! Create a simple controller that will manage basic information about the legion:

1// legion.controller.ts
2import { Controller, Get, Post, Body } from '@nestjs/common';
3
4@Controller('legion')
5export class LegionController {
6 private legionaries = [
7 { name: 'Marcus Aurelius', role: 'Centurion', experience: 10 },
8 { name: 'Julius Brutus', role: 'Engineer', experience: 5 },
9 ];
10
11 @Get()
12 getAllLegionaries() {
13 return this.legionaries;
14 }
15
16 @Post()
17 addLegionary(@Body() newLegionary: any) {
18 this.legionaries.push(newLegionary);
19 return { message: 'New legionary joined the legion!', legionary: newLegionary };
20 }
21}

Upcoming campaigns

In the following modules we will learn about:

• Services and Providers - specialist roles in the Empire
• Middleware - defense systems
• Guards - Praetorian guards
• Interceptors - signal interception
• Pipes - data processing
• Database integration - tribute warehouses
• Authentication - identification of Empire citizens
• WebSockets - communication between provinces
• Testing - preparations before a campaign

Get ready, young legionary! An exciting campaign through the provinces of modern web development awaits us. NestJS is not just a framework - it's a powerful tool for building enterprise-class applications that will help you collect the most valuable tributes in the world of programming!

Remember: a true legionary-programmer never sets out without a map (documentation) and a compass (best practices)!