27-4 Structure de base d'un projet NestJS

Dans un premier temps, d'où viens le port 3000 et le retour Hello World! lorsque l'on démarre le projet et y accède via le navigateur?

Le fichier principal de l'application est main.ts et ce fichier appelle une fonction bootstrap() (dans le sens de démarrer, à ne pas confondre avec la librairie CSS bootstrap).

src/main.ts

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(process.env.PORT ?? 3000);
}
bootstrap();

Cette fonction initialise l'application via AppModule qui est le module d'entrée (un peu comme AppComponent dans Angular est la composante racine) et écoute ensuite via le port 3000.

Dans un contexte de production, l'application roulerait sur le port 80/443 (ports TCP/IP standards pour le Web), mais en mode développement le port par défaut choisi est 3000. Cela a aussi le bénéfice de ne pas entrer en conflit avec le port 80 utilisé traditionnellement pour le web et le port 4200 d'Angular puisque nous aurons à faire rouler les deux applications en parallèle.

Module AppModule

En remontant la chaine, sous le dossier src, on remarque que le module AppModule fait référence à un contrôleur AppController et un provider AppService.

src/app.module.ts

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

Controller AppController

Voyons ce que contient AppController auquel AppModule fait référence.

src/app.controller.ts

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

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

Le contrôleur utilise le décorateur @Controller(). Ce décorateur peut prendre en paramètre une string qui représente l'URL de base utilisée par toutes les fonctions du contrôleur.

info

Un contrôleur reçoit des requêtes HTTP et retourne des réponses (ex.: données HTML ou JSON).

Comme ici aucun paramètre n'est précisé, il sera responsable de la racine de l'application (/).

Ensuite, on indique que AppController aura besoin de AppService via le constructeur. Il sera injecté automatiquement via un système d'injection de dépendances similaire à celui utilisé par Angular.

Finalement, la fonction getHello est responsable de retourner un résultat pour les requêtes HTTP de type GET (décorateur Get()). La fonction fait appel au service AppService.

AppService

Finalement, le contrôleur fait appel à AppService via une fonction getHello(), voyons ce que ce dernier contient.

src/app.service.ts

import { Injectable } from '@nestjs/common';

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

C'est donc le service au final qui contient le résultat à retourner, soit Hello World!.

Remarquez l'utilisation de @Injectable(), ce qui permet de rendre ce service disponible au mécanisme d'injection de dépendances. Identique à Angular.