Forem: Webeleon

Cursus NestJS - Les providers

WebeleonFR — Tue, 20 Sep 2022 13:32:02 +0000

Bonjour et bienvenue dans le cinquiéme module du cursus NestJS par Webeleon!
Je m'appel Julien et je serai ton guide tout au long de cette aventure.

Dans cette vidéo, je vais te parler d'un des éléments les plus important de NestJS: Les providers

Un point SOLID

Avant de rentrer dans le gras du sujet, j'aimerais faire un rapide rappel sur un concept essentiel du clean code.

SOLID est un acronyme qui représente 5 principe d'architecture logiciel qui ont pour objectif de rendres les source (orienté objet) plus lisible, compréhensible et maintenable.

Principe de responsabilité unique (Single responsibilty): Une classe ne doit avoir qu'un seul et unique role!
Principe d'ouverture-fermeture (Open-closed principle): Une classe doit être ouverte au extension (via un systéme de plugin par exemple, cf architecture hexagonale) mais fermé au modification.
Prinicpe de la substitution de Liskov (Liskov substitution): L'utilisation de classes héritant d'une interface commune doivent pouvoir s'utiliser de maniére transparente.
Principe de segregation des interfaces (Interface segregation principle): Mieux faut avoir un grand nombre d'interface spécifique q'une seul interface générique.
Principe d'inversion de dépendances (Dependency inversion principle): Il faut dépendre des abstractions et non des implémentations.

Qu'est ce qu'un provider?

Les providers (literallement: fournisseurs) sont un concept fondamental de NestJS.

Le terme peux paraitre un peu ésotérique mais il représente une réalité assez simple.

Il s'agit de classe compatible avec le systéme d'injection de dépendance de NestJS.
Pour cela il faut ajouter l'annotation @Injectable du paquet @nestjs/common sur la class cible.

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

@Injectable()
export class MonSuperProvider {}

Cette logique va permettre de créer un ensemble d'outils qui vont pouvoir être cabler facilement.

Déclaration dans un module

Afin de pouvoir utiliser notre provider via l'injection de dépendances il necessaire de le déclarer dans un module (voir même le bon module mais nous y reviendront dans la leçon suivante).

import { Module } from '@nestjs/common';
import { MonSuperProvider } from './mon-super.provider';

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

Injection

Une des grandes force des providers, c'est de pouvoir profiter du systéme d'injection de dépendance.
Une fois le provider déclaré dans un module, il est possible de l'utiliser dans n'importe quelle classe du module en l'ajoutant via le constructeur.

import { Controller, Get } from '@nestjs/common';
import { MonSuperProvider } from './mon-super.provider';

@Controller()
export class AppController {
  constructor(
    private readonly superProvider: MonSuperProvider,
  ) {}

  @Get()
  getUnTruc() {
    return this.superProvider.fetchUnTrucDansLaBDD();
  }
}

Il sera ensuite disponible dans le this de la classe. Dans cet exemple, une instance de la classe MonSuperProvider est disponible via this.superProvider dans tout la class AppController.

Les services

Les providers les plus courants sont les services.
Ils ont pour roles la gestions des données entre les controllers et les sources de données.

Pour créer un Service manuellement, il suffira d'appliquer la procédure de création d'un provider et de remplace le terme provider par Service.

Création rapide via la ligne de commande nest:

nest g service nomDuService

provider custom

Il est aussi possible de rendre injectable dans un module plus ou moins n'importe quoi en utilisant le pattern des provider custom.

Au lieu de fournir une classe dans la section providers, tu peux passer un objet qui contiendra le jeton d'injection (injection token) et le moyen de le récupérer.

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

@Module({
  imports: [],
  controllers: [],
  providers: [
    {
      provide: 'MA_CONSTANTE',
      useValue: '1234'
    },
    {
      provide: 'MON_SERVICE_MOCK',
      useValue: {
        unTruc: () => {
          // implementation
        }
      }
    },
    {
      provide: 'injection token',
      useClass: ClassToUse,
    },
    {
      provide: 'injection token',
      imports: [/* module dont dépend la factory */],
      inject: [/* providers à injecter dans la factory */],
      useFactory: async (/* dépendance injecté dans le même ordre que déclaré au dessus */) => {
        // logique permettant de construire le provider
        return // provider construit, ce qui sera injecté.
      }
    }
  ],
})
export class AppModule {}

Pour injecter un provider custom, il est necessaire d'utiliser le décorateur @Inject(injection_token).

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

@Injectable()
class EncoreUnProvider {
  constructor(
    @Inject('MA_CONSTANTE') private readonly maConstante: string,
    @Inject('MON_SERVICE_MOCK') private readonly monServiceMock: UneInterfaceOuUneClasse
  ) {}
}

Cette technique est trés utile pour la mise ne place de tests afin de limiter les dépendances.

Ceci n'est qu'une approche superficielle des providers custom, une documentation compléte est disponible en anglais

Conclusion

Laisse-moi tes questions en commentaire, je me ferai un plaisir d'y répondre.

L'intégralité du cursus est disponible sur github.

Ou viens directement les poser sur le serveur discord webeleon!

La prochaine fois nous verrons l'utilisation avancée des modules alors abonne-toi pour progresser rapidement sur NestJS!

Cursus NestJS - Validation via les DTO

WebeleonFR — Tue, 24 May 2022 09:46:29 +0000

DTO (Data Transfer Object): Une DTO est un objet qui à pour but de transferer des données entre deux process.

Dans le cadre de ce cours, elles seront principalement utilisé pour définir le format des objets que les endpoint vont accepté en entrée.
Pour les méthodes POST, PUT, PATCH, elles valideront principalement les body.
Avec la méthode GET, elles serviront à valider les query parameters.

Pourquoi valider?

Une des régles importantes du développement backend est de ne JAMAIS au grand JAMAIS faire confiance au données entré par un client.
Bloquer les requetes avec de mauvaises données permettra:

de simplifier les traitements
facilité la consistence des données persisté
sécuriser

Le second interet et d'ajouter une couche de validation au runtime pour notre application.
Typescript n'offre qu'une validation du typage à la transpilation, si une données vicié est fournis au runtime tout peu exploser...
L'utilisation de DTO validé permettra d'ajouter de la validation au runtime pour la communication entre les services.

Installer les dépendances requise pour la validation

Afin d'utiliser la validation automatique via le ValidationPipe nous avons besoin d'installer deux dépendances.

npm i --save class-validator class-transformer

Définir une DTO

Pour définir une DTO, nous allons devoir créer une classe et appliquer des décorateurs sur ses attributs.
Une liste exhaustive de décorateur des disponibles sur la page github de la bibliothèque class-validator

Par exemple, si je souhaite créer une dto pour un formulaire de connexion:

import { IsEmail, IsNotEmpty, IsString } from 'class-validator';

export class LoginDto {
  @IsEmail()
  email: string;

  @IsString()
  @IsNotEmpty()
  password: string;
}

Une liste exhaustive des annotations avec leurs options respectives est disponible dans la documentation de class-validator.
class-validator étant un wrapper autour de validator.js, certaine option sont détaillé dans la documentation de validator.js

Ajouter la validation sur une route

Maintenant que nous avons créer les régles de validation via notre DTO, il ne reste qu'à la branché sur le body d'une route post et d'appliquer le pipe de validation:

import { Body, Controller, HttpCode, Post, UsePipes, ValidationPipe } from '@nestjs/common';
import { LoginDto } from './login.dto';

@Controller('login')
export class LoginController {
  @Post()
  @HttpCode(200)
  @UsePipes(new ValidationPipe())
  login(@Body() loginDto: LoginDto) {
    return 'ok'
  }
}

Activer la validation route par route, c'est bien...
Mais c'est fastidieux quand même...

Configurer la validation globalement

Pour configurer la validation sur notre app au global il faudra éditer le fichier src/main.ts

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

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  app.useGlobalPipes(new ValidationPipe({
    // retire tout les champs qui ne sont pas déclaré dans la dto
    whitelist: true,
    // rejette les requêtes qui contiennent des champs non déclaré dans la dto
    forbidNonWhitelisted: true, 
  }));

  await app.listen(3000);
}
bootstrap();

Attention, il est necessaire de d'ajouter cette ligne dans la configuration de vos test end to end avec une configuration identique.

import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication, ValidationPipe } from '@nestjs/common';
import * as request from 'supertest';
import { AppModule } from './../src/app.module';

describe('AppController (e2e)', () => {
  let app: INestApplication;

  beforeEach(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [AppModule],
    }).compile();

    app = moduleFixture.createNestApplication();

    // Branchement de la validation global
    app.useGlobalPipes(new ValidationPipe({
      // Ne pas oublier les options de validations
    }));

    await app.init();
  });

  // La suite de test end 2 en 
})

Cursus NestJS - Les Controllers

WebeleonFR — Sat, 23 Apr 2022 14:08:35 +0000

Bienvenue dans ce nouveaux cours du cursus NestJS par Webeleon.
Je m'appel Julien et je serais ton guide tout au long de cette aventure qui fera de toi un véritable expert Nest!
Alors abonne toi pour progresser rapidement!

Aujourd'hui on va parler controlleur!

Un Contrôlleurs mais qu'est ce que c'est?

Un controlleur c'est une classe exporté sur laquelle on applique le décorateur @Controller importé depuis @nestjs/common.

import { Controller } from "@nestjs/common";

@Controller('optional-path-prefix')
export class MyController {

}

Qui est ensuite déclaré dans le module le plus proche dans la section controllers.

import { MyController } from './my-controller.controller.ts';

@Module({
  controllers: [ MyController ], 
})
export class MyModule {}

A quoi ça sert?

Un controlleur vas être utilisé pour créer des routes pour notre API.
C'est ensuite au controlleurs de faire un premier tour de validation, je te montre ça dans la prochaine vidéo.
Et d'appeler les services et autres providers qui s'occuperons de la logique métier.
Pas de stress je te montre ça bientôt. ❤️
Il est aussi de bon gout que le controlleur soit en charge de la sérialisation des erreurs et des réponses qui seront envoyé au consommateur de l'api.

Créer un controller via la ligne de commande

nest generate controller <nom>

Assez de théorie passons sur un cas pratique

Je te propose de créer rapidement une API REST pour gérer un collection de livre.

[GET] /book liste les livres dans notre collection.
[GET] /book/:id affiche les détails d'un livre. Une erreur 404 sera retourné si l'id du livre n'éxiste pas.
[POST] /book crée un livre dans notre collection
[PUT] /book/:id mise à jour d'un livre dans la collection. Une erreur 404 sera retourné si l'id du livre n'éxiste pas.
[DELETE] /book/:id suppression d'un livre dans la collection. Une erreur 404 sera retourné si l'id du livre n'éxiste pas.

Création du projet

Commence par créer un nouveau projet NestJS appelé book-api.

nest new book-api
cd book-api

maintenant génére le controlleur via la ligne commande

nest generate controller book

Si tout s'est bien passé tu es sensé avoir ces lignes dans ton terminal.

CREATE src/book/book.controller.spec.ts (478 bytes)
CREATE src/book/book.controller.ts (97 bytes)
UPDATE src/app.module.ts (322 bytes)

[GET] liste de la collection de livre

Il est temps d'éditer le fichier book/book.controller.ts.

Créer une route, c'est créer une méthode dans classe BookController.
Sur laquelle tu applique une décorateur de routage (@Get, @post, @Put, @Delete, ...).

Commençons par la liste, pour cela il faut créer un tableau comme attribut de classe et la méthode liste sur laquelle il faut appliquer le décorateur @Get() qui viens de @nestjs/common.

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

@Controller('book')
export class BookController {
  books: string[] = [
    'Apprendre NestJS, c\'est facile',
  ];

  @Get()
  list() {
    return this.books;
  }
}

Tu peux maintenant lancer ton projet nest (via la commande npm run start:dev).
Pour tester plusieurs solution s'offre à toi:

dans ton naivagateur à l'addresse http://localhost:3000/book (attention cela ne fonctionne que pour les routes en get)
Via la commande curl si tu l'as d'installer curl http://localhost:3000/book
via un outils comme postman

Pour éviter de refaire ce même test manuellement, l'ideal est d'ajouter un test end to end pour automatiser.
Histoire de rester simple, ajoute une cas de test dans le fichier test/app.e2e-spec.ts.

import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import * as request from 'supertest';
import { AppModule } from './../src/app.module';

describe('AppController (e2e)', () => {

  // ... bootstrap et test par défaut

  it('/book [GET]', () => {
    return request(app.getHttpServer())
      .get('/book')
      .expect(200)
      .expect([]);
  });
});

Super! tu sais afficher la liste par défaut!

[GET] Récupérer un livre par son index

Tu vas pouvoir ajouter la méthode pour afficher un livre par son index dans le tableau this.books.
C'est presque la même chose, tu cré une méthode getBookByIndex sur laquelle tu applique le décorateur @Get('/:index').
En passant une chaine de caractére pour définir la suite de la route cela donnera au final /book/:index.
:index signifie qu'il y a une variable dans l'url que l'on peu récupérer via le décorateur @Param('index') dans la signature de la méthode getBookById(@Param('index') index: string).

L'implémentation de la méthode est assez simple ici:

on regarde si l'index existe dans le tableau, si ce n'est pas le cas on envoie une erreur 404 en utilisant l'exception NotFoundException
on envoie ce qu'il y a dans le tableau à l'index demandé

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

@Controller('book')
export class BookController {

  // code dans l'exemple précédent!

  @Get('/:index')
  getBookByIndex(
    @Param('index') index: string,
  ) {
    if (!this.books[index]) {
      throw new NotFoundException(`Book with index ${index} does not exist!`);
    }
    return this.books[index];
  }
}

Pour tester, même techniques qu'avant mais sur les routes

http://localhost:3000/book/0
http://localhost:3000/book/1

Ajoute ces deux cas de test fonctionnel dans le fichier test/app.e2e-spec.ts pour automatiser le test.

// import dans l'exemple précédent

describe('AppController (e2e)', () => {

  // cas de test de l'exemple précédent

  it('/book/:index [GET][200]', () => {
    return request(app.getHttpServer())
      .get('/book/0')
      .expect(200)
      .expect('le secret de ji');
  });

  it('/book/:index [GET][404]', () => {
    return request(app.getHttpServer()).get('/book/1').expect(404);
  });
});

Top! On liste la collection et on affiche un élément, c'est un bon début mais pas encore suffisant!

[POST] Ajouter un livre

Il est temps maintenant de créer la méthode pour ajouter un livre dans notre collection.

Tu vas devoir créer une méthode addBook sur laquelle tu applique le décorateur @Post() qui viens encore et toujours de @nestjs/common.
Pour récupérer un élément du body de la requéte il faut utiliser le décorateur @Body(), il carrément possible de récupérer un attribut spécifique en le passant en paramétre.

import { Body, Controller, Get, NotFoundException, Param, Post } from '@nestjs/common';

@Controller('book')
export class BookController {

  // voir exemples précédent

  @Post()
  addBook(
    @Body('title') book: string
  ) {
    this.books.push(book)
    return book
  }
}

On test, cette fois le navigateur n'est pas une option car il envoie des requétes GET et il nous faut un POST en utilisant postman ou CURL.

curl --location --request POST 'http://localhost:3000/book' \
--header 'Content-Type: application/json' \
--data-raw '{
    "title": "test"
}'

// import dans les exemples précédents

describe('AppController (e2e)', () => {

  // mise en place et test dans les exemples précédents

  it('/book [POST][201]', async () => {
    await request(app.getHttpServer())
      .post('/book')
      .send({
        title: 'Super book',
      })
      .expect(201);

    await request(app.getHttpServer())
      .get('/book')
      .expect(200)
      .expect(['le secret de ji', 'Super book']);
  });
});

[PUT] mise à jour d'un livre par index

Et c'est partie pour la mise à jour d'un livre!

On retrouve une fois encore la logique de précédente.
Tu crée une méthode updateBook sur laquelle tu applique le décorateur @Put('/:index').
Il faut récupérer le title dans le body et le l'index du livre dans les paramétres de route.
Comme dans le getByIndex on vérifie l'existence du livre, on fait la mise à jour ou on renvoi un erreur 404.

import { Body, Controller, Get, NotFoundException, Param, Post, Put } from '@nestjs/common';

@Controller('book')
export class BookController {

  // exemples précédent camarade!

  @Put('/:index')
  updateBook(
    @Param('index') index: string,
    @Body('title') book: string,
  ) {
    if (!this.books[index]) {
      throw new NotFoundException(`Book with index ${index} does not exist!`)
    }
    this.books[index] = book;
    return book;
  }
}

Encore un petit curl pour toi mon ami!

curl --location --request PUT 'http://localhost:3000/book/0' \
--header 'Content-Type: application/json' \
--data-raw '{
    "title": "Nest c'\''est facile v2"
}'

Et voici le test end 2 end

// ...

describe('AppController (e2e)', () => {

  // ...

  it('/book/index [PUT][200]', async () => {
    await request(app.getHttpServer())
      .put('/book/0')
      .send({
        title: 'nouveau titre',
      })
      .expect(200);

    await request(app.getHttpServer())
      .get('/book/0')
      .expect(200)
      .expect('nouveau titre');
  });

  it('/book/index [PUT][404]', () => {
    return request(app.getHttpServer()).put('/book/1').expect(404);
  });
});

[DELETE] supprimer un livre

On à presque finis, il ne reste plus qu'à faire la suppression.
Donc, pour la suppression, une méthode deleteBook sur laquelle tu applique le décorateur @Delete('/:id').
Tu vérifie que le livre existe, si c'est le cas il faut le supprimer du tableau.

import { Body, Controller, Delete, Get, NotFoundException, Param, Post, Put } from '@nestjs/common';

@Controller('book')
export class BookController {

  // voir plus haut ;)

  @Delete('/:index')
  deleteBook(
    @Param('index') index: string
  ) {
    if (!this.books[index]) {
      throw new NotFoundException(`Book with index ${index} does not exist!`)
    }

    delete this.books[index];

    return 'deleted';
  }
}

Un curl en cadeau pour tester:

curl --location --request DELETE 'http://localhost:3000/book/0'

Et le test fonctionnel!

// ...

describe('AppController (e2e)', () => {

  // ...

  it('/book/index [DELETE][200]', async () => {
    await request(app.getHttpServer()).delete('/book/0').expect(200);
    await request(app.getHttpServer()).get('/book/0').expect(404);
  });

  it('/book/index [DELETE][404]', () => {
    return request(app.getHttpServer()).delete('/book/1').expect(404);
  });
});

Et voila! on a terminé ce petit controlleur REST.

Conclusion

Laisse-moi tes questions en commentaire, je me ferai un plaisir d'y répondre.

Un exemple complet du TP est disponible sur github https://github.com/Webeleon/Cursus-NestJS-les-controllers

Ou viens directement les poser sur le serveur discord webeleon!

La prochaine fois nous traiterons de la validation des entrées alors abonne-toi pour progresser rapidement sur NestJS!

Cursus NestJS - les modules partie 1

WebeleonFR — Sat, 12 Mar 2022 16:08:48 +0000

Bienvenue dans ce second cours du cursus NestJs par Webeleon.
Je m'appelle Julien et je serai ton guide dans cette formation NestJS qui fera de toi un véritable expert de NestJS.

Alors abonne-toi pour progresser rapidement!

Dans ce module, nous allons parler modules!

Un module?

Un module est une classe exporté sur laquelle est appliqué l'annotation @Module().
L'annotation module permet de définir des métadonnées qui vont permettre d'organiser la structure de ton application Nest.

Le module racine

Une application nest, doit avoir au minimum un module, le module racine.
Le module racine est le point d'entrée qui va permettre de définir l'arbre de dépendance de l'application.
En théorie, une petite application peu se contenter module racine App.module.ts.
Il est cependant fortement recommandé d'utiliser des modules pour organiser le code en unité de logique métier et d'encapsuler les fonctionnalités.
(Domain Driven Developement)

le décorateur `@Module`

Regardons de plus pret l'annotation @Module qui nous viens du package @nestjs/common.

Le décorateur @Module accepte un objet de configuration avec les propriétés suivantes:

imports définit les modules dont dépend le module
providers liste les providers (ou fournisseur en français) disponible pour l'injection de dépendances dans le module
controllers définit les controller à instancier pour ce module
exports permet d'exposer des providers qui seront disponible dans les modules qui importerons ce module. Je t'en parlerai en détails dans une prochaine vidéo. alors abonne toi

Créer un module

Laisse-moi te montrer deux méthodes pour créer un module.

from scratch

Pour créer un module a la manno, commence par créer un dossier avec le nom du module. Il s'agit la d'une convention et non d'une obligation.

Ensuite, à l'intérieur de ce module crée un fichier <nom du module>.module.ts. Pour l'exemple je vais créer un module pour gérer des recettes.

La prochaine étape est de créer une classe exporté sur laquelle il faut appliquer le décorateur @Module({}).
Un objet vide en configuration suffira pour le moment.

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

@Module({})
export class RecipeModule {}

Finalement, on peu déclarer le module fraichement cuisiné dans le module racine.

import { Module } from '@nestjs/common';
import { RecipeModule } from './recipe/recipe.module';

@Module({
  imports: [ RecipeModule ],
})
export class AppModule {}

via la CLI

Il est possible de réaliser la même opération via l'outils nest en seul commande à la racine du projet:

nest generate module <nom>

c'est quand même bien fait!

Conclusion

Laisse-moi tes questions en commentaire, je me ferai un plaisir d'y répondre.

Ou viens directement les poser sur le serveur discord webeleon!

Tu peux me retrouver en live tout les samedi soir à 22h30 sur twitch

La prochaine fois nous traiterons des controllers alors abonne-toi pour progresser rapidement sur NestJS!

Cursus NestJS - installation de nest

WebeleonFR — Fri, 04 Mar 2022 19:33:52 +0000

Bienvenue dans la première leçon qui est la seconde vidéo de la chaîne!
Je m'appelle Julien et je serai ton guide dans cette formation NestJS qui fera de toi un véritable expert de NestJS.

Alors abonne-toi pour progresser rapidement!

Je te retrouve dans le terminal pour installer Nest.

Pré-requis:

NestJS étant un framework typescript pour node, il nécessaire que tu aies installé Node.js, idéalement la dernière version lts (Long Term Support).

node -v

Installer la CLI nestjs

Ok, pour commencer il faut installer l'outil en ligne de commande via la commande:

npm i -g @nestjs/cli

J'utilise npm mais sens-toi libre d'utiliser un autre gestionnaire de paquet javascript.

À quoi va nous servir cet outil?

nest --help

créer de nouveaux projets nest nest new <nom du projet>
générer des modules, des contrôleurs, des services, des guards et autres joyeusetés le tout avec un fichier de test nest g|generate <schema> nom
démarrer un projet nest

Créer un projet

C'est parti pour créer un projet:

nest new nom-du-projet
cd nom-du-projet

Dans ce projet un certain nombres de script npm sont disponible:

Lancer les tests unitaires et fonctionnels (ou end 2 end)

npm run test
npm run test:e2e

Démarrer le projet en mode développement, c'est à dire avec un re-démarrage automatique lorsque les sources sont modifiées.

npm run start:dev

Transpiler la version typescript en javascript dans le dossier dist

npm run build

Démarrer la version transpiler

npm run start:prod

Appliquer le formatage standardisé du code:

npm run format

Structure du projet

src: contient les sources en typescript de l'API
test: stocke les tests end 2 end
dist: version transpilée en javascript

dans src:

main.ts => configuration et démarrage de l'application nest
app.module.ts => module principale
app.controller.ts => contrôleur utilisé pour déclarer les routes de l'API
app.service.ts => les services sont utilisés pour accéder à la base de données, faire des calculs, stocker de la logique métier

Bibliographie et liens utiles

Je serai heureux de répondre à toutes tes questions en commentaires

☎️Discord Webeleon

Cursus NestJS - Nest JS from scratch

WebeleonFR — Fri, 25 Feb 2022 22:09:41 +0000

Installation des dépendances

Pour l'occasion, créons un dossier vide:

mkdir 0-nest-from-scratch
cd 0-nest-from-scratch

Dans un premier temps, il faut initialiser npm.

npm init

Installation des dépendances de développement:

npm i -D @typescript@4.3.5 @types/node

Installation des dépendances:

npm i @nestjs/core @nestjs/common @nestjs/platform-express reflect-metadata

Configuration de Typescript

La première chose à faire dans un projet typescript est de configurer typescript via le fichier tsconfig.json

{
  "include": ["src/**/*"], 
  "compilerOptions": {
    "module": "CommonJS",
    "target": "ES2017",
    "outDir": "dist",
    "experimentalDecorators": true
  }
}

Création d'un module

Une application NestJS, ça commence par un module.
Donc on va créer le fichier src/app.module.ts.

Un module c'est une classe exportée sur laquelle on applique le décorateur @Module qui nous vient de @nestjs/common.

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

@Module({})
export class AppModule {}

Création d'un controlleur

C'est bien beau d'avoir un module mais faut-il encore en faire quelque chose.
Et pour cela nous allons créer un controlleur.
Un controlleur c'est une classe exportée sur laquelle on applique le décorateur @Controller importé de @nestjs/common.

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

@Controller()
export class AppController {}

Pour le moment, notre controlleur n'est pas très utile...
Nous allons donc lui ajouter une méthode sayHello qui retournera la string Hello Nest.

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

@Controller()
export class AppController {
  sayHello(): string {
    return 'Hello Nest';
  }
}

Une méthode, c'est bien. Une route, c'est mieux!
Pour transformer la méthode sayHello en routeur http, il suffit de lui appliquer le décorateur @Get()

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

@Controller()
export class AppController {
  @Get()
  sayHello(): string {
    return 'Hello Nest';
  }
}

Pour en finir avec notre super controlleur, ajoutons-le tout simplement dans le module que nous avons créé précédemment.
Ajoutons la classe AppController dans la section controllers des options de notre module.

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';

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

Un fichier de démarrage: `main.ts`

Top!
Maintenant que nous avons un module et un controlleur, il va nous falloir démarrer notre application.

Pour réaliser ce miracle, nous allons créer un fichier main.ts qui va se charger de compiler le module et lancer le serveur.
On commence par créer une fonction asynchrone que l'on appellera bootstrap.
Et ensuite on l'execute.

async function bootstrap() {}
bootstrap();

À l'intérieur de la fonction bootstrap, créons une variable app qui va recevoir le résultat awaiter de NestFactory.create() avec notre AppModule en paramètre.

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

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

Finalement, on await la fonction app.listen() sur le port 3000.

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

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

Il ne reste plus qu'à retourner dans le terminal pour transpiler et tester notre superbe API.

Compiler, lancer et tester

De retour dans le terminal, on peut utiliser la commande tsc installée par typescript pour transpiler dans le dossier dist.

node_modules/.bin/tsc

Une fois la transpilation terminée, on peut lancer notre API via commande:

node dist/main.js

Et pour tester, un petit curl des familles sera du meilleur des goûts.

curl http://localhost:3000

Je serai heureux de répondre à toutes vos questions en commentaires

☎️Discord Webeleon

🎁Code sur github

Validating a polymorphic body in nest JS

Julien Prugne — Thu, 27 Jan 2022 06:50:34 +0000

Sometimes, an issue rise, this time I had to validate a body that could be of two distinct forms.
I could have chosen to build a big dto mixing both classes validation.
But in the end, it was kind of ugly, lacking the inherent elegance of Nest.

Today, I'll share with you my solution and the reasons for its necessity.

Here is our target controller method signature:

import { Controller, Post } from '@nestjs/common';
import { CollegeStudentDto, OnlineStudentDto } from './student.dto';

@Controller('student')
export class StudentController {
  @Post()
  signup(signupDto: CollegeStudentDto | OnlineStudentDto) {
    return 'call the service and apply some logic'
  }
}

Looks nice, eh?
Unfortunately, it won't work. The reflected metadata used in the ValidationPipe only knows how to cast to one class.
It can't discriminate the data and guess which of the classes to use for validation.

Ok, first thing first, let's define the DTOs:

import { IsNotEmpty, IsString } from 'class-validator';

export enum StudentType {
  ONLINE = 'online',
  COLLEGE = 'college',
}

export class StudentDto {
  @IsString()
  @IsNotEmpty()
  firstName: string;

  @IsString()
  @IsNotEmpty()
  lastName: string;
}

export class CollegeStudentDto extends StudentDto {
  @IsString()
  @IsNotEmpty()
  college: string;
}

export class OnlineStudentDto extends StudentDto {
  @IsString()
  @IsNotEmpty()
  platform: string;
}

So, how can we compensate for these limitations?
Easy! use setup our own transform pipe in the @Body() annotation

import {
  BadRequestException,
  Body,
  Controller,
  Post,
  ValidationPipe,
} from '@nestjs/common';
import { CollegeStudentDto, OnlineStudentDto } from './student.dto';
import { plainToInstance } from 'class-transformer';
import { validate } from 'class-validator';

@Controller('student')
export class StudentController {
  @Post()
  signup(
    @Body({
      transform: async (value) => {
        let transformed: CollegeStudentDto | OnlineStudentDto;
        if (value.college) {
          // use plainToClass with older class-transformer versions
          transformed = plainToInstance(CollegeStudentDto, value);
        } else if (value.platform) {
          transformed = plainToInstance(OnlineStudentDto, value);
        } else {
          throw new BadRequestException('Invalid student signup');
        }

        const validation = await validate(transformed);
        if (validation.length > 0) {
          const validationPipe = new ValidationPipe();
          const exceptionFactory = validationPipe.createExceptionFactory();
          throw exceptionFactory(validation);
        }

        return transformed;
      },
    })
    signupDto: CollegeStudentDto | OnlineStudentDto,
  ) {
    if (signupDto instanceof CollegeStudentDto) {
      return 'college student';
    } else if (signupDto instanceof OnlineStudentDto) {
      return 'online student';
    }
  }
}

And that's it!
Now you know!

Questions?

I'll be glad to answers questions in the comments.

If you liked my discord consider joining my coding lair!
☎️Webeleon coding lair on discord

You can also email me and offer me a contract 💰
✉️Email me!

And since I'm a nice guy, here, take this sample repo containing a working codebase!
🎁Get the code of the tuto from github

Unit testing NestJS with Typeorm in memory

Julien Prugne — Mon, 18 Oct 2021 13:49:26 +0000

Assuming you already configured TypeORM in your NestJS project.
If you need to setup TypeORM, consider reading the awesome NestJS documentation.

For the sake of testing something, I'll setup a simple API that will serve spaceships! You can access the sample repository on github.

Install SQLITE

npm i -D better-sqlite3

A few helpers

Ok, we can write this for every test files BUT we are lazy developers and will not spend our time re-writing the same code over and over and over...

Let's write a simple helper function that will provide an easy to import pre-configured TypeORM module!
src/test-utils/TypeORMSQLITETestingModule.ts

import { TypeOrmModule } from '@nestjs/typeorm';
import { Spaceship } from '../spaceships/spaceship.entity';

export const TypeOrmSQLITETestingModule = () => [
  TypeOrmModule.forRoot({
    type: 'better-sqlite3',
    database: ':memory:',
    dropSchema: true,
    entities: [Spaceship],
    synchronize: true,
  }),
  TypeOrmModule.forFeature([Spaceship]),
];

This one is not mandatory but a simple test dataset is always a nice to have. src/test-utils/testDataset.seed.ts

import { getConnection } from 'typeorm';
import { Spaceship } from '../spaceships/spaceship.entity';

export const testDatasetSeed = async () => {
  const connection = await getConnection();
  const entityManager = connection.createEntityManager();

  entityManager.insert<Spaceship>(Spaceship, {
    name: 'moa',
    type: 'cruiser',
    origin: 'caldari',
  });
  entityManager.insert<Spaceship>(Spaceship, {
    name: 'caracal',
    type: 'cruiser',
    origin: 'caldari',
  });
  entityManager.insert<Spaceship>(Spaceship, {
    name: 'rokh',
    type: 'battleship',
    origin: 'caldari',
  });
};

Using the helpers in a test file

In order to allow tests to use the im memory database, you'll just need to call the function ...TypeOrmSQLITETestingModule() and spread it since it provide the TypeOrmModule.forRoot and TypeOrmModule.forFeature.

Finally, seed the test data (or not) await testDatasetSeed();.

import { Test, TestingModule } from '@nestjs/testing';
import { SpaceshipsService } from './spaceships.service';
import { TypeOrmSQLITETestingModule } from '../test-utils/TypeOrmSQLITETestingModule';
import { testDatasetSeed } from '../test-utils/testDataset.seed';

describe('SpaceshipsService', () => {
  let service: SpaceshipsService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      imports: [...TypeOrmSQLITETestingModule()],
      providers: [SpaceshipsService],
    }).compile();

    service = module.get<SpaceshipsService>(SpaceshipsService);
    await testDatasetSeed();
  });

  it('listSpaceships', async () => {
    const spaceships = await service.listSpaceships();
    expect(spaceships).toHaveLength(3);
  });
});

Questions?

I'll be glad to answers questions in the comments.

If you liked my discord consider joining my coding lair!
☎️Webeleon coding lair on discord

You can also email me and offer me a contract 💰
✉️Email me!

And since I'm a nice guy, here, take this sample repo containing a working codebase!
🎁Get the code of the tuto from github

Coder un système de migration pour NestJS avec mongoose

WebeleonFR — Wed, 06 Oct 2021 13:11:33 +0000

Prérequis:

Un projet NestJS fonctionel
Utiliser MongoDB et mongoose

Récemment, j'ai ressenti le besoin pressant de refactorer mon jeu discord.
C'est un projet en cours, loin d'être fini mais je ne supportais plus que les maisons soient appelées homes au lieu de houses.
Oh j'en entends déjà me dire : 'Change les labels affichés, c'est pareil!'.

Je me soucis de la consistance du nommage dans mes projets! Si les maisons sont des appartements, "c'est la porte ouverte à toutes les fenêtres".

Bref, j'enfile ma veste de chercheur et je me lance armé de mon meilleur google-fu.
Aujourd'hui, je vous présente le résultat de mon travail.

J'ai choisi d'utiliser la bibliothèque migrate.
Un outil agnostique de tout type de base de données offrant une logique simple de script de migration et de retour en arrière.
De plus, le statut des migrations peut être stocké sous n'importe quel support (en base, un fichier json, ???).

Assez parlé de moi, laissez-moi vous guider.

Installation `migrate`

Installons ce coquin!

npm i --save migrate

Crée un dossier pour stocker les scripts de migrations!

On aura besoin de deux dossiers:

mkdir src/migrations
mkdir src/migrations-utils

Le premier contiendra nos scripts de migration et le second sera notre boîte à outils.
Commencons par le second!

Quelques outils

Dans l'intro, nous avons vu que l'outil migrate fait fi du type de nos bases de données.
Nous avons donc besoin d'un script pour nous connecter à mongodb:

import { MongoClient } from 'mongodb';
import { configs } from '../config/configuration';

const MONGO_URL = configs.mongoUrl;

export const getDb = async () => {
  const client: any = await MongoClient.connect(MONGO_URL, { useUnifiedTopology: true });
  return client.db();
};

Cool! Continuons!

Migrate est un outil écrit en javascript.
Et comme nous utilisons Typescript, la meilleur chose à faire est de créer un template déjà connecté à notre mongo.

import { getDb } from '../migrations-utils/db';

export const up = async () => {
  const db = await getDb();
  /*
      La migration va ici.
   */
};

export const down = async () => {
  const db = await getDb();
  /*
      Et ici, c'est pour le retour en arrière.
   */
};

J'ai rencontré quelques soucis avec ts-node/register en utilisant migrate en ligne de commande...
Ce petit script m'a sauvé la mise!
Vas-y! Maintenant! Ajoute-le!

// eslint-disable-next-line @typescript-eslint/no-var-requires
const tsNode = require('ts-node');
module.exports = tsNode.register;

Mise à jour du `package.json`

Il est temps de mettre à jour le package.json de notre projet afin d'avoir une jolie collection de script facile à utiliser!

Un script pour générer les fichiers de migration

Ajoutons cette ligne dans la section script du fichier package.json

"migrate:create": "migrate create --template-file ./src/migrations-utils/template.ts --migrations-dir=\"./src/migrations\" --compiler=\"ts:./src/migrations-utils/ts-compiler.js\"",

--template-file ./src/migrations-utils/template.ts fourni le template, simple et efficace pour notre projet en typescript.
Le template est une façon rapide de créer la base de nos script de migration!

--migrations-dir=\"./src/migrations\" Explique à migrate où sont sensés être les scripts de migration.
Par défaut, c'est à la racine du projet...

--compiler=\"ts:./src/migrations-utils/ts-compiler.js\" Explique à migrate comment gérer les fichiers typescript.

Il suffit de lancer cette commande pour créer une migration vide en typescript dans le bon dossier!

npm run migrate:create -- <migration name>

Un script pour les migrations et un script pour revenir en arrière!

EEEEEeeet deux lignes de plus dans le package.json, toujours dans la section script!

"migrate:up": "migrate --migrations-dir=\"./src/migrations\" --compiler=\"ts:./src/migrations-utils/ts-compiler.js\" up",
"migrate:down": "migrate --migrations-dir=\"./src/migrations\" --compiler=\"ts:./src/migrations-utils/ts-compiler.js\" down"

Pas de nouvelle option ici, tout est expliqué au-dessus mais comme je suis sympa voila un petit rappel.

--migrations-dir=\"./src/migrations\" Explique à migrate où sont nos scripts de migration...

--compiler=\"ts:./src/migrations-utils/ts-compiler.js\" Explique à migrate comment gérer les fichiers typescript...

On peut maintenant exécuter le script npm run migrate:up pour les migrations et le script npm run migrate:down pour revenir en arrière.

Mais que se passe-t-il quand nous exécutons une migration?

Migrate va stocker l'état des migrations dans un fichier à la racine du projet.
Ce fichier est: migrate.json.
Il ressemble à ça:

{
  "lastRun": "1605197159478-test.ts",
  "migrations": [
    {
      "title": "1605197159478-test.ts",
      "timestamp": 1605197181474
    }
  ]
}

NE PAS COMMITER migrate.json

Questions?

Je serais heureux de répondre aux questions en commentaires.

Si cette article t'as plu, n'hésite pas à me rejoindre sur le discord Webeleon!
☎️Discord webeleon

Tu peux aussi me contacter par mail si tu cherches un freelance sympa et efficace 💰
✉️Email moi!

Et comme je suis partageur, tu trouveras les sources sur github!
🎁Récupère le code sur github!

Documentation

[TS nugget] Record

Julien Prugne — Thu, 11 Mar 2021 20:36:56 +0000

For years now I wrote my data bags like this.

export inteface Foo {
  bar: {
    [key: string]: string;
  };
}

To be honest, I always felt kind of disgusted about it...
But today, I learned the elegant way.

export interface Foo {
  bar: Record<string, string>
}

May the elegant code be with you my coding friends!

To the doc!

Building a MongoDB migration system for NestJS with mongoose

Julien Prugne — Thu, 12 Nov 2020 20:58:32 +0000

This tutorial is assuming:

You have a working NestJS project
You are using MongoDB and mongoose

In the recent past, I had an urge to do a bit of refactoring on my discord game.
Still a work in progress, but I couldn't stand anymore the fact that houses were named homes...
I already can hear you, 'just change labels displayed no one care!'.

I do care about the consistency of naming in my codebases. If homes are houses then the next thing you know is:
Canons will become wooden swords and wolves are dogs...

I spent some time online looking for solutions and I finally built something I like.
Let me present to you the result of my work.

I chose to use the migrate library since it is database agnostic, offers an easy up/down logic, and can store the migration status in any form.

Enough speaking about me, let me guide you through this journey.

Install `migrate`

Go on install the bad guy!

npm i --save migrate

Create a folder to store your migrations!

You will new two folders:

mkdir src/migrations
mkdir src/migrations-utils

The first one will store the update scripts and the seconds will store some utilities.
Let's look into the seconds.

Some little helpers

In the introduction, I told you that migrate is database agnostic.
Therefore you need to write a little mongodb connector:

import { MongoClient } from 'mongodb';
import { configs } from '../config/configuration';

const MONGO_URL = configs.mongoUrl;

export const getDb = async () => {
  const client: any = await MongoClient.connect(MONGO_URL, { useUnifiedTopology: true });
  return client.db();
};

Nice! let's keep going.

Migrate is a tool made in javascript.
And we use typescript, the best thing to do is have a little template with the database already connected.

import { getDb } from '../migrations-utils/db';

export const up = async () => {
  const db = await getDb();
  /*
      Code your update script here!
   */
};

export const down = async () => {
  const db = await getDb();
  /*
      Code you downgrade script here!
   */
};

I had some trouble with ts-node/register in migrate command line.
This little helper solved my transpilation errors!
Do the same! now! do it!

// eslint-disable-next-line @typescript-eslint/no-var-requires
const tsNode = require('ts-node');
module.exports = tsNode.register;

Update `package.json`

it's time for you to update the package.json of your project in order to have easy to use scripts for the future!

A script to generate migration files

Add this sweet line in the package.json, in the script section!

"migrate:create": "migrate create --template-file ./src/migrations-utils/template.ts --migrations-dir=\"./src/migrations\" --compiler=\"ts:./src/migrations-utils/ts-compiler.js\"",

--template-file ./src/migrations-utils/template.ts provide a template file, it's a necessary thing since we are in a typescript repo.
It also provides you an easy way to bootstrap migration just the way you like it!

--migrations-dir=\"./src/migrations\" Tell migrate where your migration scripts are stored.
By default, it's at the project root.

--compiler=\"ts:./src/migrations-utils/ts-compiler.js\" Explain to migrate how to handle typescript files.

Now, you just need to run this command to create an empty typescript migration file in the correct folder!

npm run migrate:create -- <migration name>

A script for upgrades and a script for downgrades

AAAAAAnd two more lines in the package.json, again in the scripts section!

"migrate:up": "migrate --migrations-dir=\"./src/migrations\" --compiler=\"ts:./src/migrations-utils/ts-compiler.js\" up",
"migrate:down": "migrate --migrations-dir=\"./src/migrations\" --compiler=\"ts:./src/migrations-utils/ts-compiler.js\" down"

No new options here, I already explained them but refreshing is nice.

--migrations-dir=\"./src/migrations\" Tells migrate where to find your migrations!

--compiler=\"ts:./src/migrations-utils/ts-compiler.js\" Tells migrate how to handle typescript...

You can now run update script: npm run migrate:up or downgrade script npm run migrate:down

What will happen when you run a migration?

Migrate will store your migration state in a file at the project root.
This file is called migrate.json.
It looks like this:

{
  "lastRun": "1605197159478-test.ts",
  "migrations": [
    {
      "title": "1605197159478-test.ts",
      "timestamp": 1605197181474
    }
  ]
}

DO NOT COMMIT migrate.json

Questions?

I'll be glad to answers questions in the comments.

If you liked my discord consider joining my coding lair!
☎️Webeleon coding lair on discord

You can also email me and offer me a contract 💰
✉️Email me!

And since I'm a nice guy, here, take this sample repo containing a working codebase!
🎁Get the code of the tuto from github

Documentation

Purge docker with fire

Julien Prugne — Thu, 24 Sep 2020 07:28:19 +0000

On my development machines, I need docker most of the time...

The annoying parts are:

take a shit ton of place on my SSD for images and unused containers. Like 200GB
add a lot of virtual network interfaces.... around 50 useless interfaces polluting my computer.

I won't uninstall docker but I would like to remove all containers, all volumes, all networks, and all volumes.

Start by stopping all running containers.

sudo docker stop `docker ps -qa`

then delete all containers (running and stopped)

sudo docker rm `docker ps -qa`

then remove all networks not used by at least one container. None are left so we are removing all of them...

sudo docker network prune

Now we will remove all the volumes:

sudo docker volume prune

And finally, we can remove all the images:

sudo docker images prune

Enjoy the space and silence.

ps: If you are only looking to remove unused resources go with sudo docker system prune

pps: If you are only looking to remove stopped container docker container prune -f thanks to Manuel Castellin for the tips.

Forem: Webeleon

Cursus NestJS - Les providers

Un point SOLID

Qu'est ce qu'un provider?

Déclaration dans un module

Injection

Les services

provider custom

Conclusion

Cursus NestJS - Validation via les DTO

Pourquoi valider?

Installer les dépendances requise pour la validation

Définir une DTO

Ajouter la validation sur une route

Configurer la validation globalement

Cursus NestJS - Les Controllers

Un Contrôlleurs mais qu'est ce que c'est?

A quoi ça sert?

Créer un controller via la ligne de commande

Assez de théorie passons sur un cas pratique

Création du projet

[GET] liste de la collection de livre

[GET] Récupérer un livre par son index

[POST] Ajouter un livre

[PUT] mise à jour d'un livre par index

[DELETE] supprimer un livre

Conclusion

Cursus NestJS - les modules partie 1

Un module?

Le module racine

le décorateur @Module

Créer un module

from scratch

via la CLI

Conclusion

Cursus NestJS - installation de nest

Pré-requis:

Installer la CLI nestjs

Créer un projet

Structure du projet

Bibliographie et liens utiles

Cursus NestJS - Nest JS from scratch

Installation des dépendances

Configuration de Typescript

Création d'un module

Création d'un controlleur

Un fichier de démarrage: main.ts

Compiler, lancer et tester

Validating a polymorphic body in nest JS

Questions?

Unit testing NestJS with Typeorm in memory

Install SQLITE

A few helpers

Using the helpers in a test file

Questions?

Coder un système de migration pour NestJS avec mongoose

Installation migrate

Crée un dossier pour stocker les scripts de migrations!

Quelques outils

Mise à jour du package.json

Un script pour générer les fichiers de migration

Un script pour les migrations et un script pour revenir en arrière!

Mais que se passe-t-il quand nous exécutons une migration?

Questions?

Documentation

[TS nugget] Record

Building a MongoDB migration system for NestJS with mongoose

Install migrate

Create a folder to store your migrations!

Some little helpers

Update package.json

A script to generate migration files

A script for upgrades and a script for downgrades

What will happen when you run a migration?

Questions?

Documentation

Purge docker with fire

le décorateur `@Module`

Un fichier de démarrage: `main.ts`

Installation `migrate`

Mise à jour du `package.json`

Install `migrate`

Update `package.json`