Útmutató a Nest.js-hez – REST API létrehozása Nesttel és Node-dal

Node.js háttérfejlesztőként Ön is egyetért azzal, hogy a Node.js alapértelmezés szerint nagyon csupasz, és nem tesz feltételezéseket arról, hogy mire van szüksége egy alkalmazás elkészítésekor. Ennek eredményeként Ön a felelős minden alkalmazás beállításáért, amit használni szeretne, beleértve az útválasztás kezelését, az API-hívások lebonyolítását, a TypeScript vagy a Web Socket beállítását, vagy akár az alapvető dolgokat, például a kódszervezést, a fájlstruktúrát és az elnevezési szabályokat. .

Egy nagyszabású alkalmazás kezelése nehéz feladat lehet, különösen, ha nem világos szerkezettel és szigorú kódszervezési irányelvekkel tervezték.

A Nest.js e problémák némelyikét úgy próbálja megoldani, hogy a Node.js körül egy absztrakciót hoz létre, így Ön fejlesztőként az alkalmazás problémájára összpontosíthat, nem pedig egyéb apró megvalósítási részletekre.

Ebben az útmutatóban elsajátíthatja a Nest.js alapvető alapjait, amelyek célja, hogy felgyorsuljon, hogy a Nest.js segítségével pillanatok alatt készíthessen vállalati szintű Node.js alkalmazásokat.

Minden, amit ezen az útmutatón keresztül megtanulunk, növekményes lesz; sok területet lefedve a bevezető fogalmakon. Ahhoz, hogy a legtöbbet hozza ki ebből az útmutatóból, segít a kódolásban.

Ugorjunk bele, emberek!

Mi az a Nest.js?

Tekintse a Nest.js-t a Node.js szuperkészleteként, amely elvonatkoztatja a nehéz feladatokat, eszközöket és alapkódot, miközben teljes értékű eszközkészletet ad az alkalmazásfejlesztéshez a modern JavaScript és TypeScript használatával.

A Nest.js egy beépített alkalmazásarchitektúrát biztosít, amely lehetővé teszi a fejlesztők és a csapatok számára, hogy rendkívül méretezhető, tesztelhető, laza csatolású és könnyen karbantartható létrehozását a közösségben könnyen elérhető és kiemelkedő lehetőségek és modulok, például a Express.js alkalmazások. Akár le is cserélheti az Expresst (amelyet alapértelmezés szerint a motorháztető alatt használ) a Fastify-ra, de ez azt jelentené, hogy különböző Fastify-kompatibilis könyvtárakat kell használnia az alkalmazásban.

Egyesíti a funkcionális programozás, az objektum-orientált programozás és a funkcionális reaktív programozás jellemzőit, és több mint 52.4 ezer csillaggal és 6.2 ezer villával GitHub és heti 1,784,004 XNUMX XNUMX-ig terjedő letöltési számával a progresszív Node.js keretrendszer népszerű eszköz a hatékony, méretezhető és vállalati szintű szerveroldali alkalmazások készítéséhez.

A Nest.js szolgáltatásai

A következő okok miatt a Nest.js ilyen népszerű Node.js keretrendszerré nőtte ki magát:

1. A Nest.js azért jött létre, hogy segítse a fejlesztőket monolitikus alkalmazások és mikroszolgáltatások létrehozásában.
2. Bár erős, fejlesztőbarát is dolgozni vele; könnyen használható, gyorsan megtanulható és könnyen alkalmazható.
3. Kihasználja a TypeScriptet (a JavaScript szuperkészletét), és teret ad a fejlesztőknek a futásidejű hibáktól mentes karbantartható kód írására.
4. Parancssori felülettel rendelkezik, amely segít a fejlesztők termelékenységének növelésében és a könnyű fejlesztésben.
5. A Nest.js használatával történő építés során a fejlesztési folyamatok javulnak, és időt takarítanak meg, akár egy Minimum Viable Product indításakor, akár egy alkalmazáson dolgozik, mert a Nest alapértelmezés szerint csodálatos projektmappastruktúrával rendelkezik.
6. Számos Nest-specifikus modult támogat, amelyek segítenek az általános fogalmak és technológiák integrálásában, beleértve a TypeORM-et, a GraphQL-t, a naplózást, az érvényesítést, a Mongoose-t, a WebSocketeket, a gyorsítótárat stb.
7. A Nest.js a legjobb dokumentációval büszkélkedhet bármely keretrendszerhez. Dokumentációja alapos, könnyen érthető, és segít megtakarítani a hibakeresési időt, mivel könnyedén átjön, ha valamilyen probléma megoldására van szükség.
8. A Nest.js integrálódik a Jest-tel, ami megkönnyíti az egységtesztek írását az alkalmazásokon.
9. Kis- és nagyvállalati alkalmazásokhoz egyaránt készült.

Nest.js projekt létrehozása

A Nest.js használatának megkezdéséhez a helyi gépen először telepítenie kell a Nest Command Line Interface-t (CLI), amely segít egy új Nest.js projektmappa állványzatának kialakításában, és feltölti a mappát a működéshez szükséges alapvető fájlokkal és modulokkal. Nest.js alkalmazás.

Futtassa a következő parancsot a Nest.js parancssori felület telepítéséhez:

$ npm i -g @nestjs/cli
// Or
$ yarn global add @nestjs/cli
// Or
$ pnpm add -g @nestjs/cli

Miután sikeresen telepítette a Nest.js parancssori felületet globálisan a helyi gépen, futtassa nest a parancssorban a különféle parancsok megtekintéséhez, amelyeket megérinthetünk:

$ nest

Eredmények:

Usage: nest  [options]

Options:
  -v, --version                                   Output the current version.
  -h, --help                                      Output usage information.

Commands:
  new|n [options] [name]                          Generate Nest application.
  build [options] [app]                           Build Nest application.
  start [options] [app]                           Run Nest application.
  info|i                                          Display Nest project details.
  add [options]                          Adds support for an external library to your project.
  generate|g [options]  [name] [path]  Generate a Nest element.
    Schematics available on @nestjs/schematics collection:
      ┌───────────────┬─────────────┬──────────────────────────────────────────────┐
      │ name          │ alias       │ description                                  │
      │ application   │ application │ Generate a new application workspace         │
      │ class         │ cl          │ Generate a new class                         │
      │ configuration │ config      │ Generate a CLI configuration file            │
      │ controller    │ co          │ Generate a controller declaration            │
      │ decorator     │ d           │ Generate a custom decorator                  │
      │ filter        │ f           │ Generate a filter declaration                │
      │ gateway       │ ga          │ Generate a gateway declaration               │
      │ guard         │ gu          │ Generate a guard declaration                 │
      │ interceptor   │ itc         │ Generate an interceptor declaration          │
      │ interface     │ itf         │ Generate an interface                        │
      │ middleware    │ mi          │ Generate a middleware declaration            │
      │ module        │ mo          │ Generate a module declaration                │
      │ pipe          │ pi          │ Generate a pipe declaration                  │
      │ provider      │ pr          │ Generate a provider declaration              │
      │ resolver      │ r           │ Generate a GraphQL resolver declaration      │
      │ service       │ s           │ Generate a service declaration               │
      │ library       │ lib         │ Generate a new library within a monorepo     │
      │ sub-app       │ app         │ Generate a new application within a monorepo │
      │ resource      │ res         │ Generate a new CRUD resource                 │
      └───────────────┴─────────────┴──────────────────────────────────────────────┘

Itt megmutatjuk, hogyan kell használni a parancsokat, és most megérintheti a new|n [options] [name] parancs a legelső Nest.js projekt létrehozásához:

$ nest new getting-started-with-nestjs
// Or
$ nest n getting-started-with-nestjs

Ezután a rendszer megkérdezi, hogy milyen csomagkezelőt szeretne használni:

? Which package manager would you ❤️ to use? (Use arrow keys)
  npm
  yarn
> pnpm

Nyugodtan válassza ki a választott csomagkezelőt, megyek vele pnpm. Ennek az az oka, hogy körülbelül háromszor hatékonyabb és gyorsabb, mint az NPM, és a gyors gyorsítótár-rendszerrel a PNPM is gyorsabb, mint a Yarn.

A csomagkezelő kiválasztása után a telepítési folyamat folytatódik, majd létrejön a Nest.js alkalmazás.

Most már tudod cd az újonnan létrehozott projektbe, és nyissa meg egy választott szerkesztővel:

$ cd getting-started-with-nestjs

A létrehozott projekttel a következő parancsok bármelyikével futtathatjuk:

$ npm run start
// Or
$ yarn start
// Or
$ pnpm run start

Ha egy pillantást vet a package.json fájlt, a parancsfájl szegmensben észreveszi a for értékét pnpm run start is nest start:

    
"start": "nest start",

Ez azt jelenti, hogy a Nest.js alkalmazást a következők futtatásával is futtathatja:

$ nest start

Egy pillantás a Nest.js projekt szerkezetére

Vessünk egy pillantást a Nest-alkalmazások felépítésére:

/package.json

A package.json fájl a Node.js és extenssion révén a Nest.js projekt szíve. A projekttel kapcsolatos összes metaadatot tárolja, és meghatározza a projekt különféle funkcionális tulajdonságait, amelyek az alkalmazásfüggőségek telepítéséhez vagy a projektszkriptek futtatásához szükségesek.

Már láttuk a képességét a start szkripteket.

A start:dev A profil lehetővé teszi az alkalmazás változásainak figyelését és automatikus újratöltését anélkül, hogy le kellene állítania és újra kellene indítania – és ez fejlesztésre szolgál. A start:prod A szkript akkor hasznos, ha szeretné tesztelni, hogy az alkalmazás készen áll-e az éles üzemre, valamint amikor üzembe helyezi azt a Nest.js alkalmazás tesztelésére szolgáló egyéb szkriptekkel együtt.

@nestjs/platform-express az expresst az alapértelmezett HTTP-kiszolgálóként határozza meg egy Nest-alkalmazásban.

/tsconfig.json

A tsconfig.json fájl egy JSON-ban (JavaScript Object Notation) írt fájl, amely meghatározza a Nest alkalmazás fordításához szükséges TypeScript-hez kapcsolódó beállításokat.

/nest-cli.json

Ez tartalmazza azokat a metaadatokat, amelyek a Nest-alkalmazások felépítéséhez, rendszerezéséhez vagy üzembe helyezéséhez szükségesek.

/test

Ez a könyvtár tartalmazza a Nest-tesztek futtatásához szükséges összes fájlt. A Nest a Jest-keretrendszert használja a Jest-konfigurációval végzett teszteléshez jest-e2e.json fájlt.

/src

A src könyvtár a Nest projekt magjának szülőmappája. Tartja a main.ts fájl, amely az a fájl, ahol a Nest alkalmazás elindul. A munka a main.ts a fájlt be kell tölteni AppModule amelyről importálják /src/app.module.ts.

Az útmutató későbbi részében megismerjük a modulokat; a Nest.js alkalmazások egyik fő összetevője.

A AppModule egy osztály, amely modulként jön létre a @Module lakberendező. Ban,-ben app.module.ts fájl AppService ból ből ./app.service és a AppController ból ből ./app.controller importálják is.

A AppController is egy osztály, amely a @Controller lakberendező, míg a AppService egy osztály, amely a @Injectable kommentár.

A Nestben az a klassz, hogy nagyon kevés dekorátor van benne, akik bármely osztályhoz metaadatokat adnak hozzá, és ezek a metaadatok határozzák meg az osztály célját, például:

• @Controller()osztályt vezérlővé alakít át.
• @Module() osztályt modullá alakít.
• @Injectable() osztályt szolgáltatóvá alakít át.

Szintén a src könyvtár a app.controller.spec.ts fájl, amely a vezérlők tesztfájlja.

segítségével futtathatjuk az alkalmazást nest start.

Az alkalmazás ekkor indul http://localhost:3000 böngészőjében:

Módosíthatjuk a címen megjelenő tartalmat http://localhost:3000, átmegy a app.service.ts fájl, ahol az indexútvonal szolgáltatója meg van határozva.

A Nest.js alkalmazás építőkövei

A Nest.js alkalmazásnak három fő összetevője van:

1. Modulok
2. Vezérlők
3. szolgáltatók

A Nest-alkalmazások építőkövei megismerésekor először tisztítsuk meg a Nest-projektet úgy, hogy töröljük a app.controller.spec.ts, ./app.service, app.module.tsés ./app.controller fájlok; távozik csak main.ts, a nulláról induló fejlesztési életciklus emulálásához.

Ezen a ponton, amikor eltávolítjuk az importált AppModule fájl a main.ts, akkor a rendszer arra kéri, hogy a „modul” argumentuma nem került megadásra.

A Nest-alkalmazások építőelemeinek bemutatásához egy egyszerű felhasználói profil implementációt tekintünk meg egy REST API létrehozásával, amely kezeli a CRUD műveleteket egy objektumon.

Modulok

A src mappát hozzon létre egy újat app.module.ts fájlt, majd hozzon létre egy AppModule osztályú, amelyet exportálunk.

Ezután importálja a AppModule osztályba be main.ts, és fuss nest start.

navigáljon http://localhost:3000 böngészőjében, és 404-es hibaüzenetet kap:

Ennek az az oka, hogy még nem határoztunk meg útvonalat a Nest alkalmazás alap URL-címéhez.

Vissza app.module.ts, megvan a AppModule osztályunk még nem Nest-modul. Ahhoz, hogy Nest modul legyen, hozzáadjuk a @Module() lakberendező, amelyről importált @nestjs/commonmajd elhaladunk egy üres tárgy mellett.

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

export class AppModule {}

Most van egy Nest.js modulunk!

A @Module() A dekorátor lehetővé teszi a fejlesztők számára, hogy metaadatokat határozzanak meg egy osztályról a Nest alkalmazásban.

Abban az esetben, ha több modul van, például felhasználói modul, rendelési modul, csevegési modul stb. app.module.ts a Nest alkalmazás összes többi moduljának regisztrálásához kell használni.

Útvonalak létrehozása; Vezérlők

Vezérlőkre van szükség az útvonalak létrehozásához a Nest-alkalmazásokban. A vezérlő célja, hogy konkrét kéréseket fogadjon egy Nest-alkalmazásra vonatkozóan; az alkalmazáson belüli különböző útvonalak kérés- és válaszciklusának vezérlése.

Amikor a kliens HTTP-kérést küld a Nest alkalmazáshoz, a kérés útvonalának megfelelő útvonal kezeli a kérést, és visszaadja a megfelelő választ.

Vezérlő létrehozásához a Nest alkalmazásban ki kell használnunk a @Controller() lakberendező.

A src könyvtárba, hozzon létre egy új fájlt app.contoller.ts, és abban definiálhatunk egy Nest-vezérlőt:

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

@Controller({})

export class AppController {}

Ez az! Van egy nagyon szép vezérlőnk, de egy új útvonal létrehozásához először a Nest alkalmazásunkat kell tudatnunk a létrehozott vezérlővel.

Ennek elérése érdekében gondoskodunk az importálásról AppController az app.module.ts fájlban, és adjon meg információkat a vezérlőkről @Module() dekorátor – vezérlők sorozataként:

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

@Module({
  controllers: [AppController],
})

export class AppModule {}

GET kérések kezelése

Ezután definiálunk egy egyszerűt getUser() útvonal (a @Get() meghatározott útvonalra irányuló HTTP GET kérések kezelésére használt dekorátor), amely alapútvonalként szolgál, ugyanezt a böngészőben érhetjük el a következő címen: https://localhost:3000:

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

@Controller({})

export class AppController {
  @Get()
  getUser() {
    return 'I am a great person';
  }
}

Ennek eredményeként:

Hmm, itt csak egy karakterláncot adunk vissza, de mi van, ha egy tárgyat akarunk visszaadni? Karakterlánc helyett definiálhatunk egy objektumot:

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

@Controller({})

export class AppController {
  @Get()
  getUser() {
    return { name: 'Uchechukwu Azubuko', country: 'Nigeria' };
  }
}

navigáljon http://localhost:3000 a böngészőben, és látni fogja az objektumot:

Az alapútvonaltól távol, mit szólna ehhez hasonló útvonal létrehozásához http://localhost:3000/user az összes felhasználó lekéréséhez?

Többféle módon is létrehozhatunk egy vezérlőt egy ilyen útvonal kezelésére.

Az egyik módja az lenne, hogy egy új módszert definiáljunk a @Get() lakberendező/kezelő.

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

@Controller({})

export class AppController {
  @Get()
  getUser() {
    return { name: 'Uchechukwu Azubuko', country: 'Nigeria' };
  }
}

A Nest.js dekorátorokat vagy kezelőket biztosít az összes HTTP-módszerhez, beleértve @Get(), @Post(), @Put(), @Delete(), @Patch(), @Options()és @Head().

A @All() A dekorátor meghatároz egy végpontot, amely kezeli az összes különféle módszert.

POST kérések kezelése

POST kéréseket is definiálhatunk az adatok adatbázisban való tárolására, a segítségével @Post() lakberendező:

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

@Controller({})
export class AppController {
  @Post()
  store() {
    return 'Post request successful';
  }
}

Ezután teszteljük a POST kérést a Postman segítségével, és észrevesszük, hogy a karakterlánc a megadott módon sikeresen visszaküldésre kerül.

Kérdezhetnéd, mi van akkor, ha én is többet akarok tenni, mint visszaküldeni az adatokat? Talán adatküldésre.

Ehhez be kell illesztenie az adatokat az útvonal metódusába, az ábrán látható módon:

import { Controller, Post, Req } from '@nestjs/common';
import { Request } from 'express';

@Controller({})
export class AppController {
  @Post()
  store(@Req() req: Request) {
    return req.body;
  }
}

Most, amikor teszteljük a POST kérést a Postman segítségével, meg tudjuk tekinteni a küldött adatokat. Ebben az esetben ez csak egy üres objektum:

Dinamikus útválasztás útvonalparaméterekkel

Tegyük fel, hogy dinamikus adatokat szeretne elfogadni egy kérés részeként. Először meg kell határoznunk a tokent az útvonal útvonalában, hogy megjegyezzük a dinamikus pozíciót az útvonalon/URL-en, majd a @Param() dekorátor, az útvonal paraméter így érhető el:

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

@Controller({})
export class AppController {
  @Get('/:userId')
  getUser(@Param() userId: number) {
    return userId;
  }
}

A userId sikeresen visszakerült:

Aszinkron kérések kezelése

A Nest.js különféle megközelítésekkel képes kezelni az ígéretet visszaadó aszinkron kéréseket:

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

@Controller({})
export class AppController {
  @Get()
  async findAll(): Promise {
    return [];
  }
}

A fenti megközelítésben az aszinkronitást a async kulcsszó. Egy másik megközelítés az RxJS megfigyelhető adatfolyamok visszaadása:

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

@Controller({})
export class AppController {
  @Get()
  findAll(): Observable {
    return of([]);
  }
}

Itt a Nest.js előfizet a motorháztető alatti forrásra, és a streamelés befejeztével automatikusan az utoljára kiadott értéket veszi fel.

Átirányítások kezelése a Nestben

A @Redirect() dekorátor a válasz átirányítására szolgál egy másik URL-re. A @Redirect() A dekorátor két argumentumot fogad el – az URL-t, amelyre át kell irányítani, és az állapotkódot az átirányításkor, mindkettő nem kötelező:

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

@Controller({})
export class AppController {
  @Get()
  @Redirect('https://www.ucheazubuko.com', 302)
  getSite() {
    return { url: 'https://stackabuse.com' };
  }
}

Állapotkód visszaküldése

A Nest.js szerveren kezelt bármely kérés állapotkódjának visszaadásához a @HttpCode(…) könnyen átjön.

A Nestben a GET kérések alapértelmezett állapotkódja 200, a POST kérésé 201, a hibakérésé 304

A szerverkérés állapotkódja az alábbiak szerint határozható meg:

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

@Controller({})
export class AppController {
  @Post()
  @HttpCode(204)
  create() {
    return 'This action adds a new user to the app.';
  }
}

DELETE kérések kezelése

Hasonlóan a POST kéréshez, a törlési kérelmet a következőképpen lehet kezelni:

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

@Controller({})
export class AppController {
  @Delete('/:userId')
  delete(@Param() params: { userId: number }) {
    return params;
  }
}

UPDATE kérések kezelése

A szerveren lévő konkrét adatok frissítésére vonatkozó kérés a következővel kezelhető @Patch() lakberendező:

import { Controller, Patch, Req} from '@nestjs/common';
import { Request } from 'express';

@Controller({})
export class AppController {
  @Patch('/:userId')
  update(@Req() req: Request) {
    return req.body;
  }
}

Most, hogy számos módszert láttunk a tipikus vezérlők meghatározására, amelyeket gyakran használunk egy robusztus szerveren, fontos megjegyezni, hogy a vezérlőnek karcsúnak, letisztultnak és használati esetenként definiáltnak kell lennie, így ha van másik vezérlő a meghatározásához. user útvonalak, akkor külön könyvtárat kell létrehozni és dedikálni ugyanazok kezelésére – távol a AppController.

Aztán be user.controller.ts, beállíthatjuk az összes útvonalkezelőt úgy, hogy előtagként szerepeljen /user/ az alábbi kód beírásával:

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

@Controller('/user')
export class UserController {
  @Get()
  getUser() {
    return 'I am from the user controller';
  }
}

Ezután regisztráljon UserController a vezérlők tömbjeiben app.modules.ts:

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

@Module({
  controllers: [AppController, UserController],
})

export class AppModule {}

Amikor felé navigálunk https:localhost:3000/user, sikeresen visszatér:

Annak érdekében, hogy a projektmappa a jelenleginél még rendezettebb legyen, definiálhatunk a user.module.ts fájl, ahol meghatározzuk a UserController:

import { Module } from '@nestjs/common';
import { UserController } from './user.controller';

@Module({
  controllers: [UserController],
})

export class UserModule {}

Ezután importálja UserModule bele app.module.ts:

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

@Module({
  controllers: [AppController],
  imports: [UserModule],
})

export class AppModule {}

Ezzel ugyanazt a hatást érhetjük el, mint korábban.

szolgáltatók

Minden adatlekérést az adatbázisból a szolgáltatóknak kell kezelniük a vezérlők helyett, hogy egy absztrakciós réteget hozzanak létre a felhasználó számára elérhető kód és a potenciálisan érzékeny adatokkal kölcsönhatásba lépő kód között. E rétegek között – érvényesítés állítható be az adatbázis megfelelő kezelésének biztosítására. A Nest CLI segítségével szolgáltatókat hozhatunk létre a következő szolgáltatások generálásával:

$ nest g s user

Ez létrehozza a UserService ahol az összes üzleti logikát meghatároznánk a UserControllerÚgy, hogy UserController csak kéréseket és válaszokat kezel. Ban ben user.service.ts, látjuk, hogy a @Injectable() a dekorátor az osztály meghatározására szolgál. A Nestben a használata a @Injectable() A dekorátor célja, hogy a szolgáltatásokat, adattárakat vagy segítők osztályát szolgáltatóvá alakítsa.

A szolgáltatók a konstruktoron keresztül jutnak be egy osztályba. Nézzünk meg közelebbről egy példát.

Korábban, ben user.controller.ts, definiáltuk az üzleti logikát a felhasználói objektum lekéréséhez, de most ugyanezt kell meghatároznunk a UserService:

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

@Controller({})

export class AppController {
  @Injectable()
  get() {
    return { name: 'Uchechukwu Azubuko', country: 'Nigeria'; };
  }
}

Ezután a user.controller.ts fájlban, definiáljunk egy konstruktort a UserController osztály. Ebben a kivitelezőben privátot biztosítunk userService, amely a UserService osztály. Ezzel a magánjelleggel tudjuk megragadni azt az üzleti logikát, amelyet korábban a felhasználók lekéréséhez definiáltunk:

import { Controller, Get } from '@nestjs/common';
import { UserService } from './user.service';

@Controller('/user')
export class UserController {
  constructor(private userService: UserService) {}
  @Get()
  getUser() {
    return this.userService.get();
  }
}

Így a UserController osztály, most attól függ UserService néven ismert fogalomban
függőségi injekció.

Ugyanígy a logika mindkettőben user.controller.ts és a user.service.ts a fájlok ennek megfelelően frissülnek:

import {
  Controller,
  Delete,
  Get,
  Param,
  Patch,
  Post,
  Req,
} from '@nestjs/common';
import { Request } from 'express';
import { UserService } from './user.service';

@Controller('user')
export class UserController {
  constructor(private userService: UserService) {}
  @Get()
  getUsers() {
    return this.userService.get();
  }
  @Get('/:userId')
  getUser(@Param() param: { userId: number }) {
    return this.userService.getUser(param);
  }
  @Post()
  store(@Req() req: Request) {
    return this.userService.create(req);
  }
  @Patch('/:userId')
  update(@Req() req: Request, @Param() param: { userId: number }) {
    return this.userService.update(req, param);
  }
  @Delete()
  delete(@Param() param: { userId: number }) {
    return this.userService.delete(param);
  }
}

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

@Injectable()
export class UserService {
  get() {
    return { name: 'Uchechukwu Azubuko', country: 'Nigeria' };
  }
  getUser(param: { userId: number }) {
    return param;
  }
  create(req: Request) {
    return req.body;
  }
  update(req: Request, param: { userId: number }) {
    return { body: req.body, param };
  }
  delete(param: { userId: number }) {
    return param;
  }
}

Most pedig ellenőrizzük, hogy a végpontok úgy működnek-e, ahogyan kell, a Postman segítségével.

A függőségi befecskendezés megfejtése a Nest.js-ben

Egy alkalmazás kisebb összetevőinek, például osztálynak vagy modulnak az összeállításakor az osztály egy másik osztály vagy modul funkcionalitásától függhet, például ha API-hívások indításához egy másik osztály által biztosított HTTP-szolgáltatást kell igénybe venni, vagy szolgáltatási rétegek, amelyek kölcsönhatásba lépnek a perzisztencia réteggel.

A vezérlőkön belül a függőségek biztosíthatók függőségi injekció.

A függőségi befecskendezés olyan programozási koncepció és minta, amely kifejezi, hogy az alkalmazás részei hogyan kerülnek az alkalmazás más részeihez, amelyeknek szüksége van rá, oly módon, hogy nagy kohéziót, de laza csatolást biztosítsanak.

A Nest támogatja a függőségi befecskendezést, és a Nest-alkalmazásokban is felhasználhatja projektje modularitásának fokozására.

Egy gyakorlati illusztrációt a következőképpen ábrázolunk:

Tegyük fel, hogy az A osztály használja a B osztály néhány funkcióját. Ekkor azt mondják, hogy A osztály a B osztálytól függ. Így ahhoz, hogy B osztályt használhassunk az A osztályban, először létre kell hoznunk a B osztály egy példányát (vagyis egy B osztályú objektum): const b = new B ().
Az osztálypéldány létrehozásának feladatának átvitele egy másik osztályba, és az adott osztály függőségének közvetlen felhasználása (a befecskendező komponens) függőségi injekciónak nevezzük.

Általában egy osztálynak kizárólag a funkcióinak teljesítésére kell koncentrálnia, ahelyett, hogy különféle objektumok létrehozására használnák, amelyekre szükség lehet vagy sem.

A függőségi injekció előnyei.

1. Segít az egységtesztben.
2. A függőségi befecskendezésnél az alapkód lecsökken, mivel a függőségek inicializálását az injektor komponens végzi.
3. A kérelem kiterjesztésének folyamata könnyebbé válik.
4. A függőségi befecskendezés elősegíti a laza csatlakozást.

A kérések hasznos terheinek feltárása

Ne feledje, hogy a különböző kéréskezelőknél, mint például a POST és a PATCH, meg tudtuk érinteni a kérést, amelyet a szerver küldött a @Req() lakberendező. Ebben azonban többről van szó.

A teljes kérelem objektum lekérése helyett egyszerűen megérinthetjük a kérelem objektum bizonyos részeit, amelyekre szükségünk van.
Így a Nest különféle dekorátorokat kínál, amelyek a HTTP-útkezelőkkel együtt használhatók az Express of Fastify objektumok eléréséhez:

Fészek díszítők	Az elért objektum gyorsítása vagy expresszálása
`@Request(), @Req()`	`req`
`@Response(), @Res()`	`re"s".
`@Következő()`	`következő`
`@Session()`	`req.session`
`@Param(param?: string)`	`req.params` / `req.params[param]`
`@Body(param?: string)`	`req.body` / `req.body[param]`
`@Query(param?: string)`	`req.query` / `req.query[param]`
`@Headers(param?: string)`	`req.headers` / `req.headers[param]`
`@Ip()`	`req.ip`
`@HostParam()`	`req.hosts`

Tipikus példa lenne a @Req() lakberendező amelyet korábban használtunk, hogy hozzáférjünk az eredmény testéhez, a @Body() amely már közvetlen hozzáférést biztosít számunkra a kérés törzséhez fúrás nélkül:

@Post()
store(@Body() body: any) {
  return this.userService.create(body);
}

@Patch('/:userId')
update(@Body() body: any, @Param() param: { userId: number }) {
  return this.userService.update(body, param);
}

create(body: any) {
  return body;
}

update(body: any, param: { userId: number }) {
  return { body: body, param };
}

Egyes esetekben előfordulhat, hogy csak a kérés hasznos adatának adott tulajdonságait szeretné lekérni. Ebben az esetben meg kell határoznia egy adatátviteli objektum (DTO) sémát. Az adatátviteli séma egy olyan objektum, amely a beolvasandó objektum másolatát határozza meg, de elsősorban az adatok átvitelére szolgál a menteni vagy visszakeresni kívánt objektum és a perzisztencia réteg között. Általában, mivel ez a folyamat sebezhetőbb a támadásokkal szemben, a DTO általában nem tartalmaz annyi érzékeny adatpontot. Ez a jellemző azt is lehetővé teszi, hogy az objektumnak csak bizonyos mezőit kérje le.

A Nestben ajánlatos osztályokat használni az adatátviteli objektumok meghatározásához, mivel az osztályok értéke a fordítás során megmarad.

Feltételezve, hogy a kérés törzsében van token, és Ön nem akarja lekérni vagy frissíteni ezeket az adatokat, akkor a DTO az alábbiak szerint definiálható:

@Patch('/:userId')
update(
  @Body() updateUserDto: { name: string; email: string },
  @Param() param: { userId: number },
) {
  return this.userService.update(updateUserDto, param);
}

update(
  updateUserDto: { name: string; email: string },
  param: { userId: number },
) {
  return { body: updateUserDto, param };
}

Azonban észreveheti, hogy meghatároztuk a típust updateUserDto kétszer; ban ben user.service.ts és user.controller.ts, de a kódjainkat SZÁRAZON kell tartanunk (Don't Repeat Yourself), hogy ne ismételjük magunkat a kódbázis körül.

Ehhez egy új mappában /user/dto a /user könyvtárba, létre kell hoznunk egy fájlt /update-user.dto.ts a ... val .dto.ts kiterjesztés, ahol definiáljuk és exportáljuk a UpdateUserDto osztályban való használatra user.service.ts és a user.controller.ts fájlok:

export class UpdateUserDto {
  name: string;
  email: string;
}

...
import { UpdateUserDto } from './dto/update-user.dto';

@Patch('/:userId')
update(
  @Body() updateUserDto: UpdateUserDto,
  @Param() param: { userId: number },
) {
  return this.userService.update(updateUserDto, param);
}

...
import { UpdateUserDto } from './dto/update-user.dto';

update(updateUserDto: UpdateUserDto, param: { userId: number }) {
  return { body: updateUserDto, param };
}

Cső és érvényesítés

Tegyük fel, hogy ellenőrizni kell azokat az adatokat, amelyeket akkor kapunk, amikor egy kérés érkezik a kiszolgálón keresztül.

A Nestben az alkalmazásba bejutó vagy onnan kilépő adatok helyességét két függőséget telepítő csövek segítségével tesztelhetjük – class-validator és a class-transformer.

A cső egy osztály, amelyet a @Injectable() dekorátor (tehát a csövek szolgáltatók), amely megvalósítja a PipeTransform felület. Átalakítják az adatokat a kívánt formátumra, és úgy értékelik ki az adatokat, hogy ha az adatot érvényesnek találják, akkor változatlanul továbbadják, különben kivételt dobnak. Pipe használatához az adott csőosztály egy példányát kell a megfelelő környezethez kötni.

A class-validator csomag lehetővé teszi lakberendezők és nem lakberendezők érvényesítését, felhasználásával validator.js belsőleg. Amíg a class-transformer A csomag lehetővé teszi objektumok átalakítását egy osztály példányává, osztály objektummá alakítását, valamint objektumok szerializálását vagy deszerializálását bizonyos feltételek alapján.

A Nest által biztosított nyolc cső a következő:

• ValidationPipe
• ParseArrayPipe
• ParseIntPipe
• ParseUUIDPipe
• ParseBoolPipe
• DefaultValuePipe
• ParseEnumPipe
• ParseFloatPipe

A Nestben való érvényesítés bemutatásához ebben az útmutatóban a beépített eszközt fogjuk használni ValidationPipe amely lehetővé teszi az érvényesítés érvényesítését kérésre hasznos terhelésekre, és jól kombinálható a class-validator csomag; A speciális szabályok egyszerű megjegyzésekkel vannak deklarálva az adatátviteli objektum/helyi osztály deklarációiban minden modulban.

A beépített használat megkezdéséhez ValidationPipe amelyből exportálják @nestjs/common, telepítsük a class-validator és a class-transformer csomagok:

$ npm i --save class-validator class-transformer
# Or
$ yarn add class-validator class-transformer
# Or
$ pnpm install class-validator class-transformer

Ezután navigáljon main.ts ahol megkötjük ValidationPipe az alkalmazás gyökér szintjén annak biztosítására, hogy alkalmazásunk összes végpontja védve legyen az érvénytelen adatok lekérésével szemben:

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

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

bootstrap();

Ezt követően az egyes modulok adatátviteli objektum deklarációiban néhány érvényesítési szabályt adunk meg úgy, hogy minden egyes adathoz deklaráljuk a megfelelő adatellenőrzéseket. Esetünkben a megfelelő érvényesítési szabályokat deklarálnánk name és a email in UpdateUserDto:

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

export class UpdateUserDto {
  @IsString()
  name: string;

  @IsEmail()
  email: string;
}

A @IsString() dekorátor ellenőrzi, hogy egy adott adat valódi karakterlánc-e, és a @IsEmail() A validátor ellenőrzi, hogy az adott adat e-mail-e, különben hamis értéket ad vissza, és kivételt dob.

Most, ha megpróbáljuk a PATCH kérjen egy felhasználói profilt, és adjon meg egy számot érvényes e-mail helyett, például kivételt dob:

Ezekkel nagyon szép érvényesítést kaptunk a Nest alkalmazásunkban.

Az érvényesítés közben ValidationPipe, lehetőség van olyan tulajdonságaink szűrésére is, amelyeket nem szeretnénk, hogy metóduskezelőnk megkapja. Például ha a kezelőnk csak azt várja el name és a email tulajdonságok, de egy kérésben szerepel a country ingatlan, tudjuk eltávolítani a country tulajdonság a kapott objektumból beállítással whitelist nak nek true amikor példányosítunk ValidationPipe:

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

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true,
    }),
  );
  await app.listen(3000);
}

bootstrap();

Csövek kötése a módszer paramétereinek szintjén

Csövek is meghatározhatók params, is. Ehhez a csövet a metódus param szintjén kötjük össze.

Eddig, bár mi határoztuk meg a userId hogy szám legyen, akkor észrevehetné, hogy ha kérést nyújtunk be a userId karakterláncként attól függetlenül sikeresnek bizonyul:

Annak biztosítása érdekében, hogy az értéke userId mindig számnak kell lennie, akkor kötődni fogjuk a getUser() metóduskezelő egy érvényesítési ellenőrzéssel, amely ugyanazt biztosítja:

...
import { ParseIntPipe } from '@nestjs/common';

@Get('/:userId')
getUser(@Param('userId', ParseIntPipe) userId: number) {
  return this.userService.getUser(userId);
}

getUser(userId: number) {
  return { userId };
}

A ParseIntPipe meghatározza a beépített ParseInt Pipe-ot, és biztosítja, hogy az adatok, amelyeken ez fut, egész számok legyenek.

Most, amikor elkészítjük a GET kérelmet egy érvénytelennek userId Az „ab” karakterlánc ellenőrzése sikertelen, és a rendszer kivételt dob ​​a-val 400 állapotkód:

De numerikus érték esetén az érvényesítés sikeresen megy:

A megfelelő érvényesítés érdekében más metóduskezelőket is frissíthetünk ennek megfelelően:

import {
  Body,
  Controller,
  Delete,
  Get,
  Param,
  ParseIntPipe,
  Patch,
  Post,
  Req,
} from '@nestjs/common';
import { Request } from 'express';
import { UserService } from './user.service';

@Controller('user')
export class UserController {
  constructor(private userService: UserService) {}
  @Get()
  getUsers() {
    return this.userService.get();
  }
  @Get('/:userId')
  getUser(@Param('userId', ParseIntPipe) userId: number) {
    return this.userService.getUser(userId);
  }
  @Post()
  store(@Req() req: Request) {
    return this.userService.create(req);
  }
  @Patch('/:userId')
  update(
    @Body() updateUserDto: { name: string; email: string },
    @Param('userId', ParseIntPipe) userId: number,
  ) {
    return this.userService.update(updateUserDto, userId);
  }
  @Delete()
  delete(@Param('userId', ParseIntPipe) userId: number) {
    return this.userService.delete(userId);
  }
}

import { Injectable } from '@nestjs/common';
import { Request } from 'express';
import { UpdateUserDto } from './dto/user-update.dto';

@Injectable()
export class UserService {
  get() {
    return { name: 'Uchechukwu Azubuko', country: 'Nigeria' };
  }
  getUser(userId: number) {
    return { userId };
  }
  create(req: Request) {
    return req.body;
  }
  update(updateUserDto: UpdateUserDto, userId: number) {
    return { body: updateUserDto, userId };
  }
  delete(userId: number) {
    return { userId };
  }
}

Mostantól biztosítottuk a legjobb gyakorlati technikát az alkalmazásunkba – esetleg külső forrásból – bármely időpontban bekerülő adatok érvényesítésére.

Következtetés

Ebben az útmutatóban megismerheti a Node.js blokk legújabb gyermekét; Nest.js, és minden, ami az induláshoz szükséges, ha alkalmazást szeretne vele készíteni. Megtanulta, mi az a Nest, annak funkciói, hogyan hozhat létre Nest-projektet, hogyan kezelheti a Nest-alkalmazásba bejövő adatokat, és hogyan érvényesítheti a bejövő adatokat. Összességében megismerte bármely Nest-alkalmazás építőelemeit, és az egyes összetevők által a Nest.js-alkalmazások számára biztosított értékeket.

Ettől a ponttól kezdve még nagyon sokat kell tanulnunk egy vállalati szintű alkalmazás Nesttel való felépítésével kapcsolatban, de sikeresen lefedte azokat az alapvető fogalmakat, amelyek segítségével minden előttünk álló feladathoz hozzájuthat.

Figyeljen egy új útmutatóra a jövőben, amelyből megtanuljuk, hogyan építsünk nyugodt API-t Nest és MySQL segítségével.

Köszönöm, hogy elolvasta!

További források

Nest.js dokumentumok
Angular Docs