Debuter avec NestJS

Pourquoi NestJS ?

NestJS est un framework Node.js pour construire des applications server-side en utilisant JavaScript et TypeScript. Il a été créé par Kamil Mysliwiec, qui l'a ensuite développé avec une équipe de contributeurs. NestJS offre une structure modulaire et un design orienté objet qui facilite la création d'applications robustes et évolutives.

En tant que développeur senior avec 10 ans d'expérience, j'ai eu l'occasion de travailler sur des projets de grande envergure nécessitant une architecture solide et maintenable. NestJS m'a permis de développer des applications backend performantes et fiables, tout en offrant un environnement de développement agréable avec son système de modules et d'injection de dépendances.

Prerequis

Pour suivre ce tutoriel, vous aurez besoin des éléments suivants :

• Node.js (version recommandée : v14.0.0 ou supérieure)
• npm (Node Package Manager) (version recommandée : v6.0.0 ou supérieure)

Vous pouvez installer ces outils en suivant les instructions sur le site officiel de Node.js.

Concepts fondamentaux

1. Structure du Projet NestJS

NestJS utilise une structure modulaire pour organiser son code. Chaque module peut contenir des contrôleurs (pour gérer les requêtes HTTP), des services (pour encapsuler la logique métier) et des entités (pour représenter les données).

// src/app.module.ts
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';

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

2. Contôleur (Controller)

Les contrôleurs gèrent les requêtes HTTP et appellent les services appropriés pour traiter ces requêtes.

// src/app.controller.ts
import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

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

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }
}

3. Service (Service)

Les services contiennent la logique métier de l'application.

// src/app.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class AppService {
  getHello(): string {
    return 'Hello World!';
  }
}

4. Middleware

Les middleware sont des fonctions qui s'exécutent avant ou après les contrôleurs.

// src/middleware/logger.middleware.ts
import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`Request...`);
    next();
  }
}

Mise en pratique : projet fil rouge

Nous allons créer un gestionnaire de tâches simple avec NestJS. Le but est d'avoir une API REST qui permet de créer, lire, mettre à jour et supprimer des tâches.

Étape 1 : Initialiser le Projet

nest new task-manager
cd task-manager

Étape 2 : Créer un Module pour les Tâches

nest generate module tasks

Cela crée un fichier tasks.module.ts et un répertoire tasks.

Étape 3 : Créer un Service pour gérer les Tâches

nest generate service tasks

Cela crée un fichier tasks.service.ts dans le répertoire tasks.

// src/tasks/tasks.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class TasksService {
  private readonly tasks: Task[] = [];

  create(task: Task) {
    this.tasks.push(task);
    return task;
  }

  findAll(): Task[] {
    return this.tasks;
  }

  findOne(id: number): Task {
    return this.tasks.find(task => task.id === id);
  }

  update(id: number, task: Task): Task {
    const index = this.tasks.findIndex(t => t.id === id);
    if (index !== -1) {
      this.tasks[index] = { ...this.tasks[index], ...task };
      return this.tasks[index];
    }
    return null;
  }

  remove(id: number): void {
    const index = this.tasks.findIndex(task => task.id === id);
    if (index !== -1) {
      this.tasks.splice(index, 1);
    }
  }
}

Étape 4 : Créer un Contrôleur pour gérer les Tâches

nest generate controller tasks

Cela crée un fichier tasks.controller.ts dans le répertoire tasks.

// src/tasks/tasks.controller.ts
import { Controller, Get, Post, Body, Param, Put, Delete } from '@nestjs/common';
import { TasksService } from './tasks.service';
import { Task } from './task.entity';

@Controller('tasks')
export class TasksController {
  constructor(private readonly tasksService: TasksService) {}

  @Post()
  create(@Body() task: Task): Task {
    return this.tasksService.create(task);
  }

  @Get()
  findAll(): Task[] {
    return this.tasksService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: number): Task {
    return this.tasksService.findOne(id);
  }

  @Put(':id')
  update(@Param('id') id: number, @Body() task: Task): Task {
    return this.tasksService.update(id, task);
  }

  @Delete(':id')
  remove(@Param('id') id: number): void {
    this.tasksService.remove(id);
  }
}

Étape 5 : Créer une Entité pour les Tâches

nest generate class task.entity

Cela crée un fichier task.entity.ts dans le répertoire tasks.

// src/tasks/task.entity.ts
export interface Task {
  id: number;
  title: string;
  description?: string;
  completed: boolean;
}

Étape 6 : Ajouter le Middleware de Journalisation

Ajoutons le middleware de journalisation que nous avons créé précédemment.

nest generate middleware logger

Cela crée un fichier logger.middleware.ts dans le répertoire src.

Editons main.ts pour utiliser ce middleware :

// src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { LoggerMiddleware } from './middleware/logger.middleware';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.use(LoggerMiddleware);
  await app.listen(3000);
}
bootstrap();

Étape 7 : Tester l'API

Vous pouvez maintenant tester votre API en utilisant curl ou un outil comme Postman.

## Créer une tâche
curl -X POST http://localhost:3000/tasks -H "Content-Type: application/json" -d '{"id":1,"title":"Task 1","description":"First task","completed":false}'

## Lire toutes les tâches
curl http://localhost:3000/tasks

## Mettre à jour une tâche
curl -X PUT http://localhost:3000/tasks/1 -H "Content-Type: application/json" -d '{"id":1,"title":"Task 1 Updated","description":"Updated task","completed":true}'

## Supprimer une tâche
curl -X DELETE http://localhost:3000/tasks/1

Erreurs frequentes et debugging

1. Cannot find module '@nestjs/common'

npm install @nestjs/common

2. Nest can't resolve module 'tasks' in ...

Assurez-vous que le fichier tasks.module.ts est bien créé dans le répertoire src/tasks.

3. Property 'create' does not exist on type 'TasksService'

Assurez-vous que la méthode create est bien définie dans le service TasksService.

// src/tasks/tasks.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class TasksService {
  create(task: Task) {
    // Logique pour créer une tâche
  }
}

Pour aller plus loin

1. Authentification JWT : Ajoutez une authentification sécurisée à votre application.
2. Documentation API : Utilisez Swagger pour générer automatiquement la documentation de votre API.
3. Tests unitaires et d'intégration : Écrivez des tests pour vous assurer que votre application fonctionne correctement.

Défi pratique

Créez une API REST pour un blog avec les endpoints suivants :

• GET /posts
• POST /posts
• GET /posts/:id
• PUT /posts/:id
• DELETE /posts/:id

En utilisant ce tutoriel, vous devriez être capable de créer rapidement une application backend robuste et fonctionnelle.