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 공급자

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 acronym qui représente 5principe d'architecture logiciel qui ont pour objectif de rendres les source(orienté objet) plus lisible, compréhensible et maintenable.

Principe de responsabilité unique(단일 책임): Une classe ne doit avoir qu'un seul et unique role!

Principe d'ouverture-fermeture(열림 폐쇄 원리): Une classe doit être ouverte au extension (un systéme de plugin par exemple, cf 아키텍처 육각형 참조) mais fermé au 수정.

Prinicpe de la replacement de Liskov(리스코프 대체): L'utilisation de classes héritant d'une interface commune doivent pouvoir s'utiliser de maniére transparente.

Principe de segregation des interface(인터페이스 분리 원칙): 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 공급자?

Les provider(문자 그대로: fournisseurs)는 NestJS의 기본 개념입니다.

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

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.

Declaration dans un 모듈

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 {}

주입

Une des grandes force des provider, 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 constructor.

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 lethis de la classe. 예를 들어 클래스 인스턴스MonSuperProvider는 AppController 클래스this.superProvider를 통해 사용할 수 없습니다.

레 서비스

Les provider les plus courants sont les 서비스.
역할 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.

la ligne de commande nest를 통한 신속한 생성:

nest g service nomDuService

공급자 맞춤

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

Aulieu de fournir une classe dans la section provider, 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 {}

인젝터를 제공자 맞춤형으로 따르십시오. 데코레이션 도구 사용이 필요합니다@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 provider custom, une documentation compléte est disponible en anglais

결론

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

L'intégralité du cursus est disponible surgithub .

Ou viens directement les poser sur le serveurdiscord webeleon!

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