Nest.js-i juhend – REST API loomine Nesti ja Node'iga

Node.js-i taustaprogrammi arendajana nõustute, et vaikimisi on Node.js väga tühi ja ei tee mingeid eeldusi selle kohta, mida rakenduse loomisel vajate. Selle tulemusel vastutate kõige selle seadistamise eest, mida soovite rakenduses kasutada, sealhulgas marsruutimise haldamise, API-kõnede tegemise, TypeScripti või Web Socketsi seadistamise või isegi põhiliste asjade, nagu koodikorraldus, failistruktuur ja nimetamistavad. .

Suuremahulise rakenduse haldamine võib olla keeruline ülesanne, eriti kui see ei olnud loodud selge struktuuri ja rangete koodikorralduse juhistega.

Nest.js püüab mõnda neist probleemidest lahendada, luues Node.js-i ümber abstraktsiooni, et saaksite arendajana keskenduda rakenduse probleemile, mitte muudele pisiasjadele.

Selles juhendis saate teada Nest.js-i põhialused ülalt alla, mille eesmärk on viia teid kiirusega, et saaksite Nest.js-i abil kiiresti luua ettevõttetasemel Node.js-i rakendusi.

Kõik, mida me selle juhendi kaudu õpime, on järkjärguline; mis hõlmab paljusid sissejuhatavate kontseptsioonide teemasid. Sellest juhendist maksimumi saamiseks aitab see kaasa kodeerida.

Sukeldume otse sisse, inimesed!

Mis on Nest.js?

Mõelge Nest.js-ile kui Node.js-i superkomplektile, mis eemaldab keerulised ülesanded, tööriistad ja standardkoodi, lisades samal ajal täieõigusliku tööriistakomplekti teie rakenduste arendamiseks kaasaegse JavaScripti ja TypeScripti abil.

Nest.js pakub kasutusvalmis rakendusarhitektuuri, mis võimaldab arendajatel ja meeskondadel luua väga skaleeritavaid, testitavaid, lõdvalt ühendatud ja hõlpsasti hooldatavaid, kasutades kogukonnas hõlpsasti kättesaadavaid ja silmapaistvaid valikuid ja mooduleid, nagu need, mis on saadaval Express.js rakendused. Võite isegi vahetada Expressi (mida see vaikimisi kapoti all kasutab) Fastify vastu, kuid see tähendaks, et peate võib-olla kasutama oma rakenduses erinevaid Fastify-ühilduvaid teeke.

See ühendab endas funktsionaalse programmeerimise, objektorienteeritud programmeerimise ja funktsionaalse reaktiivse programmeerimise funktsioonid ning rohkem kui 52.4 6.2 tärni ja XNUMX XNUMX kahvliga. GitHub ja iganädalase allalaadimiste arvuga kuni 1,784,004 XNUMX XNUMX, on progressiivne Node.js raamistik populaarne tõhusate, skaleeritavate ja ettevõtte tasemel serveripoolsete rakenduste loomiseks.

Teenuse Nest.js funktsioonid

Järgnevalt on toodud põhjused, miks Nest.js on muutunud nii populaarseks Node.js raamistikuks.

1. Nest.js loodi selleks, et aidata arendajatel luua nii monoliitseid rakendusi kui ka mikroteenuseid.
2. Kuigi see on võimas, on sellega ka arendajasõbralik töötada; lihtne kasutada, kiiresti õppida ja hõlpsasti rakendatav.
3. See kasutab TypeScripti (JavaScripti superkomplekt) juba karbist välja ja võimaldab arendajatel kirjutada hooldatavat koodi, mis ei sisalda käitusvigu.
4. Sellel on käsurea liides, mis aitab tõsta arendajate tootlikkust ja arendamise lihtsust.
5. Nest.js-iga ehitamisel täiustatakse arendusprotsesse ja säästetakse aega, olenemata sellest, kas käivitate minimaalse elujõulise toote või töötate rakenduse kallal, kuna Nestil on vaikimisi hämmastav projektikaustastruktuur.
6. See toetab mitmesuguseid Nesti-spetsiifilisi mooduleid, mis aitavad integreerida levinud kontseptsioone ja tehnoloogiaid, sealhulgas TypeORM, GraphQL, logimine, valideerimine, Mongoose, WebSockets, vahemällu salvestamine jne.
7. Nest.js võib kiidelda sellega, et tal on mis tahes raamistiku jaoks parimad dokumendid. Selle dokumentatsioon on põhjalik, kergesti arusaadav ja aitab silumisaega kokku hoida, kuna see tuleb probleemideta läbi, kui probleemile on vaja lahendust.
8. Nest.js integreerub Jestiga, mis teeb rakendustes ühikutestide kirjutamise lihtsaks.
9. See on loodud nii väikeste kui ka suuremahuliste ettevõtete rakenduste jaoks.

Nest.js projekti loomine

Nest.js-i kasutamise alustamiseks kohalikus arvutis peate esmalt installima Nesti käsurea liidese (CLI), mis aitaks luua uue Nest.js-i projektikausta ja täita kausta põhifailide ja moodulitega, mida on vaja Nest.js rakendus.

Käivitage Nest.js-i käsurealiidese installimiseks järgmine käsk:

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

Kui olete Nest.js CLI globaalselt oma kohalikku arvutisse installinud, võite käivitada nest käsureal, et näha erinevaid käske, mida saame kasutada:

$ nest

Tulemused:

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                 │
      └───────────────┴─────────────┴──────────────────────────────────────────────┘

Siin näidatakse teile, kuidas käske kasutada, ja nüüd saate seda kasutada new|n [options] [name] käsk oma esimese Nest.js projekti loomiseks:

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

Järgmisena küsitakse, millist paketihaldurit soovite kasutada:

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

Valige julgelt omal valikul pakihaldur, ma lähen kaasa pnpm. Seda seetõttu, et see on umbes kolm korda tõhusam ja kiirem kui NPM ning kiire vahemälusüsteemiga on PNPM ka kiirem kui Yarn.

Pärast paketihalduri valimist jätkub installiprotsess, seejärel luuakse rakendus Nest.js.

Nüüd sa saad cd vastloodud projekti ja avage see oma valitud redaktoriga:

$ cd getting-started-with-nestjs

Kui projekt on nüüd loodud, saame selle käivitada ühe järgmistest käskudest:

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

Kui heidate pilgu peale package.json faili, märkate skripti segmendis väärtust pnpm run start is nest start:

    
"start": "nest start",

See tähendab, et saate rakendust Nest.js ka käitada, käivitades:

$ nest start

Pilk Nest.js projekti struktuurile

Vaatame lähemalt, kuidas Nesti rakendus on üles ehitatud.

/package.json

. package.json fail on Node.js ja extenssioni kaudu Nest.js projekti süda. See sisaldab kõiki projekti metaandmeid ja määratleb projekti erinevad funktsionaalsed omadused, mida on vaja rakendussõltuvuste installimiseks või projekti skriptide käitamiseks.

Oleme juba näinud võimet start skript.

. start:dev profiil võimaldab jälgida rakenduse muudatusi ja seda automaatselt uuesti laadida, ilma et oleks vaja rakendust peatada ja taaskäivitada – ja see on mõeldud arendamiseks. The start:prod skript on kasulik, kui soovite testida, kas teie rakendus on tootmisvalmidus, ja kui juurutate selle tootmisrežiimis koos muude skriptidega rakenduse Nest.js testimiseks.

@nestjs/platform-express defineerib ekspressi Nesti rakenduse HTTP vaikeserverina.

/tsconfig.json

. tsconfig.json fail on JSON-is (JavaScript Object Notation) kirjutatud fail, mis määratleb Nesti rakenduse kompileerimiseks vajalikud TypeScriptiga seotud suvandid.

/nest-cli.json

See sisaldab metaandmeid, mida on vaja Nesti rakenduste loomiseks, korraldamiseks või juurutamiseks.

/test

See kataloog sisaldab kõiki Nesti testide käitamiseks vajalikke faile. Nest kasutab Jesti konfiguratsiooniga testimiseks Jesti raamistikku jest-e2e.json faili.

/src

. src kataloog on Nesti projekti põhikaust. See hoiab main.ts faili, mis on fail, kust Nesti rakendus käivitub. Töökoht main.ts fail tuleb laadida AppModule mis on imporditud /src/app.module.ts.

Hiljem selles juhendis tutvume moodulitega; üks Nest.js-i rakenduse põhikomponente.

. AppModule on klass, mis luuakse moodulina, kasutades @Module dekoraator. Aastal app.module.ts faili AppService Alates ./app.service ja AppController Alates ./app.controller on ka imporditud.

. AppController on ka klass, mis luuakse kasutades @Controller dekoraator, samas AppService on klass, mis luuakse kasutades @Injectable märkus.

Nesti lahe on see, et sellel on väga vähe dekoraatoreid, kes lisavad igale klassile metaandmeid ja need metaandmed määravad selle klassi eesmärgi, näiteks:

• @Controller()muudab klassi kontrolleriks.
• @Module() muudab klassi mooduliks.
• @Injectable() muudab klassi pakkujaks.

Ka src kataloog on app.controller.spec.ts fail, mis on kontrollerite testfail.

Saame rakendust käivitada kasutades nest start.

Rakendus käivitub kell http://localhost:3000 teie brauseris:

Saame muuta sisu, mis kuvatakse aadressil http://localhost:3000, minnes aadressile app.service.ts faili, kus määrati indeksi marsruudi pakkuja.

Rakenduse Nest.js ehitusplokid

Nest.js-i rakendusel on kolm peamist komponenti.

1. Moodulid
2. Kontrollerid
3. Providers

Nesti rakenduse ehitusplokkide tundmaõppimisel puhastagem esmalt Nesti projekt, kustutades app.controller.spec.ts, ./app.service, app.module.tsja ./app.controller failid; lahkudes just main.ts, et jäljendada nullist lähtuvat arendustsüklit.

Sel hetkel, kui eemaldame imporditud AppModule fail alates main.ts, kuvatakse meile teade, et „mooduli” argumenti ei esitatud.

Nesti rakenduse ehitusplokkide demonstreerimiseks vaatleme lihtsat kasutajaprofiili juurutamist, luues REST API-i, mis käsitleb objektil CRUD toiminguid.

Moodulid

aasta src kaust loo uus app.module.ts faili, seejärel looge an AppModule klass, mida ekspordime.

Järgmisena importige AppModule klassi sisse main.ts, ja jookse nest start.

Liigu http://localhost:3000 brauseris ja kuvatakse tõrketeade 404:

Põhjus on selles, et me pole veel Nesti rakenduse baas-URL-i marsruuti määratlenud.

Tagasi app.module.ts, meil on AppModule klass, mis meil on, ei ole veel Nesti moodul. Selle Nesti mooduliks muutmiseks lisame @Module() dekoraator, mis on imporditud @nestjs/commonsiis möödume tühjast objektist.

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

export class AppModule {}

Nüüd on meil moodul Nest.js!

. @Module() dekoraator võimaldab lubada arendajatel Nesti rakenduses klassi metaandmeid määratleda.

Kui mooduleid on mitu, näiteks kasutajate moodul, tellimuste moodul, vestlusmoodul jne, app.module.ts tuleks kasutada kõigi teiste Nesti rakenduse moodulite registreerimiseks.

Marsruutide loomine; Kontrollerid

Nesti rakendustes marsruutide loomiseks on vaja kontrollereid. Kontrolleri eesmärk on saada konkreetseid taotlusi Nesti rakenduse kohta. päringu- ja vastusetsükli kontrollimine rakenduses erinevatel marsruutidel.

Kui klient saadab Nesti rakendusele HTTP-päringu, käsitleb päringu marsruut, mis vastab päringu esitamise marsruudile, ja tagastab asjakohase vastuse.

Nesti rakenduses kontrolleri loomiseks peame kasutama @Controller() dekoraator.

aasta src kataloogi, looge uus fail app.contoller.ts, ja selles saame määratleda Nesti kontrolleri:

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

@Controller({})

export class AppController {}

See on kõik! Meil on väga tore kontroller, kuid uue marsruudi loomiseks peame esmalt oma Nesti rakendusele loodud kontrollerist teada andma.

Selle saavutamiseks impordime kindlasti AppController failis app.module.ts ja määratlege teave selles olevate kontrollerite kohta @Module() dekoraator – kontrollerite massiivina:

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

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

export class AppModule {}

GET-i taotluste käsitlemine

Seejärel määratleme lihtsa getUser() marsruut (koos @Get() dekoraator, mida kasutatakse HTTP GET-i päringute käsitlemiseks määratud teele), et olla baasmarsruudina, pääseme sellele juurde brauseris aadressil https://localhost:3000:

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

@Controller({})

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

Selle tulemuseks on:

Hmm, siin tagastame vaid stringi, aga mis siis, kui tahaksime objekti tagastada? Stringi asemel saame määratleda objekti:

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

@Controller({})

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

Liigu http://localhost:3000 brauseris ja näete objekti:

Baasmarsruudist eemal, kuidas oleks sarnase marsruudi loomisega http://localhost:3000/user kõigi kasutajate toomiseks?

Sellise marsruudi haldamiseks saame luua kontrolleri mitmel viisil.

Üks võimalus oleks määratleda uus meetod, kasutades @Get() dekoraator/käsitleja.

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

@Controller({})

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

Nest.js pakub dekoraatoreid või töötlejaid kõikide erinevate HTTP-meetodite jaoks, sealhulgas @Get(), @Post(), @Put(), @Delete(), @Patch(), @Options()ja @Head().

. @All() dekoraator määratleb lõpp-punkti, mis käsitleb kõiki erinevaid meetodeid.

POST-i taotluste käsitlemine

Samuti saame määratleda POST-päringud andmete andmebaasis salvestamiseks, kasutades @Post() dekoraator:

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

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

Seejärel testime POST-päringut Postmani abil ja märkame, et string tagastatakse edukalt, nagu on määratletud.

Võite küsida, et mis siis, kui ma tahan teha rohkem kui andmeid tagastada? Võib-olla andmete saatmiseks.

Selleks peate sisestama andmed marsruudimeetodi sees, nagu näidatud:

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

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

Nüüd, kui testime POST-päringut Postmaniga, saame vaadata saadetavaid andmeid. Sel juhul on see lihtsalt tühi objekt:

Dünaamiline marsruutimine marsruudi parameetritega

Oletame, et soovite päringu osana aktsepteerida dünaamilisi andmeid. Esiteks peame marsruudil marsruudil dünaamilise asukoha märkimiseks määrama märgi, seejärel kasutage @Param() dekoraator, marsruudi parameetrile pääseb juurde järgmiselt:

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

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

. userId tagastatakse edukalt:

Asünkroonsete taotluste käsitlemine

Nest.js suudab käsitleda asünkroonseid taotlusi, mis annavad lubaduse, kasutades erinevaid lähenemisviise.

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

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

Ülaltoodud lähenemisviisi korral käsitletakse asünkroonsust kasutades async märksõna. Teine lähenemisviis on RxJS-i vaadeldavate voogude tagastamine:

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

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

Siin tellib Nest.js kapoti all oleva allika ja kui voog on lõppenud, võtab see automaatselt viimase väljastatud väärtuse.

Ümbersuunamiste käsitlemine Nestis

. @Redirect() dekoraatorit kasutatakse vastuse ümbersuunamiseks teisele URL-ile. The @Redirect() dekoraator aktsepteerib kahte argumenti – URL, kuhu ümber suunata, ja olekukood ümbersuunamisel, mis mõlemad on valikulised:

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

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

Olekukoodi tagastamine

Nest.js serveris käsitletud päringu olekukoodi tagastamiseks @HttpCode(…) tuleb kergesti läbi.

Nestis on GET-päringute vaikeolekukood 200, POST-i päring on 201, veapäring on 304

Serveripäringu olekukoodi saab määratleda järgmiselt:

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.';
  }
}

Kustutamistaotluste käsitlemine

Sarnaselt POST-i päringu tegemisega saab kustutamistaotlust käsitleda järgmiselt:

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

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

VÄRSKENDUSTE taotluste käsitlemine

Serveris olevate konkreetsete andmete värskendamise taotlust saab käsitleda kasutades @Patch() dekoraator:

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

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

Nüüd, kui oleme näinud erinevaid viise tüüpiliste kontrollerite määratlemiseks, mis meil sageli tugevas serveris on, on oluline märkida, et kontroller peaks olema lahja, puhas ja iga kasutusjuhtumi jaoks määratletud, nii et kui defineerimiseks on olemas mõni muu kontroller. user marsruute, siis tuleks luua eraldi kataloog ja pühendada sama käitlemiseks – eemal AppController.

Siis sisse user.controller.ts, saame konfigureerida kõik selles olevad marsruudihaldurid, et need oleksid eesliitega /user/ kirjutades koodi, nagu allpool näidatud:

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

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

Järgmisena registreeruge UserController kontrollerite massiivides 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 {}

Kui me navigeerime https:localhost:3000/user, naaseb edukalt:

Et projekti kaust oleks veelgi korralikum kui praegu, saame määratleda a user.module.ts faili, kus me määratleme UserController:

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

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

export class UserModule {}

Seejärel importige UserModule sisse 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 {}

Sellega saame saavutada sama efekti, mis varem.

Providers

Kogu andmete toomisega andmebaasist peaksid tegelema teenusepakkujad, mitte kontrollerid, et luua kasutajale suunatud koodi ja potentsiaalselt tundlike andmetega suhtleva koodi vahele abstraktsioonikiht. Nende kihtide vahel – andmebaasi nõuetekohase käitlemise tagamiseks saab seadistada valideerimise. Nesti CLI-ga saame luua pakkujaid, luues teenuseid:

$ nest g s user

See loob a UserService kus me määratleksime kogu äriloogika UserControllerNii, et UserController käsitleb ainult päringuid ja vastuseid. sisse user.service.ts, näeme, et @Injectable() klassi määratlemiseks kasutatakse dekoraatorit. Nestis kasutatakse @Injectable() dekoraatori eesmärk on muuta teenused, hoidlad või abistajad teenusepakkujaks.

Pakkujaid süstitakse klassi selle konstruktori kaudu. Vaatame üksikasjalikult näidet.

Varem, aastal user.controller.ts, olime määratlenud kasutajaobjekti hankimise äriloogika, kuid nüüd peaksime sama määratlema ka UserService:

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

@Controller({})

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

Järgmisena user.controller.ts faili, määratleme konstruktori failis UserController klass. Selles konstruktoris pakume privaatset userService, mis on tüüp UserService klass. Just selle privaatsusega saame kasutada äriloogikat, mille oleme kasutajate toomiseks varem määratlenud:

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();
  }
}

Malthus, UserController klass, oleneb nüüd sellest UserService klassi mõistes tuntud kui
sõltuvussüst.

Samamoodi loogika mõlemas user.controller.ts ja user.service.ts faile värskendatakse vastavalt:

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

Nüüd kontrollime, kas lõpp-punktid töötavad nii nagu nad peaksid, kasutades Postmani.

Sõltuvussüsti demüstifitseerimine rakenduses Nest.js

Rakenduse väiksemate komponentide (nt klassi või mooduli) koostamisel võib teie klass sõltuda mõne teise klassi või mooduli funktsionaalsusest, näiteks vajadusest kasutada API-kõnede tegemiseks mõne teise klassi pakutavat HTTP-teenust või teeninduskihid, mis suhtlevad püsivuskihiga.

Sõltuvusi saab kontrollerite sees pakkuda kaudu sõltuvussüst.

Sõltuvussüst on programmeerimiskontseptsioon ja -muster, mis väljendab seda, kuidas rakenduse osad edastatakse rakenduse teistele osadele, mis neid vajavad, nii, et see tagab suure sidususe, kuid lõdva sidestuse.

Nest toetab sõltuvuse süstimist ja saate seda oma Nesti rakendustes oma projekti modulaarsuse suurendamiseks kasutada.

Praktiline illustratsioon on kujutatud järgmiselt:

Oletame, et klass A kasutab mõnda klassi B funktsionaalsust. Siis öeldakse, et klass A sõltub klassist B. Seega selleks, et kasutada klassi B klassis A, peame kõigepealt looma klassi B eksemplari (st looma B-klassi objekt): const b = new B ().
Klassi eksemplari loomise ülesande ülekandmist teise klassi ja ette nähtud klassi sõltuvuse otsest kasutamist (injektorkomponent) nimetatakse sõltuvuse süstimiseks.

Tavaliselt peaks klass keskenduma ainult oma funktsioonide täitmisele, selle asemel, et seda kasutada erinevate objektide loomiseks, mida see võib vajada või mitte.

Sõltuvussüsti eelised.

1. See aitab ühikutestimisel.
2. Sõltuvuspõhise süstimise korral vähendatakse standardkoodi, kuna sõltuvuste lähtestamise teeb pihusti komponent.
3. Taotluse pikendamise protsess muutub lihtsamaks.
4. Sõltuvussüst aitab võimaldada lahtist sidumist.

Taotluste kasulike koormuste uurimine

Pidage meeles, et erinevate päringutöötlejate puhul, nagu POST ja PATCH, suutsime kasutada päringut, mille server saadab @Req() dekoraator. Siiski on selles midagi enamat.

Selle asemel, et hankida kogu päringuobjekt, saame lihtsalt puudutada konkreetseid taotlusobjekti osi, mida vajame.
Seega pakub Nest erinevaid dekoraatoreid, mida saab kasutada koos HTTP marsruudi käitlejatega, et pääseda juurde Express of Fastify objektidele:

Pesakuunistajad	Fastify või Express objekt, millele on juurdepääs
`@Request(), @Req()`	`req`
`@Response(), @Res()`	`re"s".
`@Järgmine()`	`järgmine`
`@Session()`	`req.session`
`@Param(param?: string)`	"req.params" / "req.params[param]".
`@Keha(param?: string)`	„req.body” / „req.body[param]”.
`@Query(param?: string)`	„req.query” / „req.query[param]”.
`@Päised(param?: string)`	`req.headers` / `req.headers[param]`
`@Ip()`	`req.ip`
"@HostParam()".	`req.hosts`

Tüüpiline näide oleks asendamine @Req() dekoraator, mida kasutasime varem, et saada juurdepääs tulemuse korpusele, koos @Body() mis annab meile juba ilma puurimiseta otsese juurdepääsu päringu sisule:

@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 };
}

Mõnel juhul võite soovida hankida ainult päringu kasuliku koormuse konkreetsed atribuudid. Sel juhul peaksite määratlema andmeedastusobjekti (DTO) skeemi. Andmeedastusskeem on objekt, mis määratleb allalaaditava objekti koopia, kuid mida kasutatakse peamiselt andmete ülekandmiseks objekti, mis tuleb salvestada või tuua, ja püsivuskihi vahel. Kuna see protsess on rünnakute suhtes haavatavam, ei sisalda DTO tavaliselt nii palju tundlikke andmepunkte. See omadus võimaldab hankida ka ainult teatud objekti välju.

Nestis on andmeedastusobjekti määratlemiseks soovitatav kasutada klasse, kuna klasside väärtus säilib kompileerimise ajal.

Eeldades, et päringu sisul on luba ja te ei soovi selliseid andmeid hankida ega värskendada, saab DTO määratleda järgmiselt:

@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 };
}

Siiski märkate, et oleme tüübi määranud updateUserDto kaks korda; sisse user.service.ts ja user.controller.ts, kuid peame oma koodid KUIVAD hoidma (Don’t Repeat Yourself), et me ei kordaks end koodibaasi ümber.

Selleks uude kausta /user/dto aasta /user kataloogi, peame looma faili /update-user.dto.ts koos .dto.ts laiendus, kus me määratleme ja ekspordime UpdateUserDto klassis kasutamiseks user.service.ts ja user.controller.ts failid:

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

Toru ja valideerimine

Oletame, et serveri kaudu päringu tegemisel saadud andmed on vaja kinnitada.

Nestis saame testida rakendusse sisenevate või sealt väljuvate andmete õigsust, kasutades torusid, mis paigaldavad kaks sõltuvust – class-validator ja class-transformer.

Toru on klass, mis on määratletud @Injectable() dekoraator (seega torud on pakkujad), mis rakendab PipeTransform liides. Nad teisendavad andmed soovitud vormingusse ja hindavad andmeid nii, et kui andmed leitakse olevat kehtivad, edastatakse need muutmata kujul, vastasel juhul tehakse erand. Toru kasutamiseks peate siduma konkreetse toruklassi eksemplari sobiva kontekstiga.

. class-validator pakett võimaldab valideerida dekoraatoreid ja mittedekoraatoreid, kasutades validator.js sisemiselt. Samal ajal kui class-transformer pakett võimaldab objekte teisendada klassi eksemplarideks, klassi objektideks ning objekte teatud kriteeriumide alusel järjestada või deserialiseerida.

Nesti pakutavad kaheksa toru on:

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

Selles juhendis Nesti valideerimise demonstreerimiseks kasutame sisseehitatud ValidationPipe mis võimaldab jõustada päringu kasulike koormuste valideerimist ja sobib hästi class-validator pakett; konkreetsed reeglid deklareeritakse lihtsate märkustega andmeedastusobjekti/kohaliku klassi deklaratsioonides igas moodulis.

Sisseehitatud seadme kasutamise alustamiseks ValidationPipe millest eksporditakse @nestjs/common, laske meil installida class-validator ja class-transformer pakendid:

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

Järgmisena liikuge sellele main.ts kuhu me seome ValidationPipe rakenduse juurtasemel tagamaks, et kõik meie rakenduse lõpp-punktid on kaitstud kehtetute andmete toomise eest:

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();

Järgmisena lisame iga mooduli andmeedastusobjekti deklaratsioonides mõned valideerimisreeglid, deklareerides iga üksiku andmete jaoks sobivad andmekontrollid. Meie puhul deklareeriksime asjakohased valideerimisreeglid name ja email in UpdateUserDto:

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

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

  @IsEmail()
  email: string;
}

. @IsString() dekoraator kontrollib, kas antud andmed on tõeline string, ja @IsEmail() validaator kontrollib, kas antud andmed on meil, vastasel juhul tagastab see vale ja teeb erandi.

Kui nüüd proovime teha a PATCH kasutajaprofiilile päringu ja sisestage kehtiva e-posti aadressi asemel number, näiteks tehakse erand:

Nendega on meie Nesti rakenduses väga hea valideerimine.

Valideerimise ajal koos ValidationPipe, on võimalik filtreerida ka meie atribuute, mida me ei soovi, et meie meetodikäsitleja saaks. Näiteks kui meie käitleja ainult eeldab name ja email omadused, kuid päring sisaldab ka a country vara, saame eemaldada country omadus tulemuseks olevast objektist seadistuse abil whitelist et true kui me instantseerime 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();

Torude sidumine meetodi parameetrite tasemel

Torud saab ka määratleda params, samuti. Selleks seome toru meetodi parameetri tasemel.

Varem, kuigi me määratlesime userId kui on number, märkaksite, et kui teeme päringu rakendusega userId stringina osutub see edukaks hoolimata:

Tagamaks, et väärtus userId peab alati olema arv, kuulutame selle siduvaks getUser() meetodikäsitleja valideerimiskontrolliga, mis tagab sama:

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

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

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

. ParseIntPipe määratleb sisseehitatud ParseInt Pipe'i ja tagab, et andmed, mille vastu see käivitatakse, peavad olema täisarvud.

Nüüd, kui teeme a GET taotlus kehtetule userId stringi "ab" puhul valideerimine nurjub ja erand tehakse koos a-ga 400 olekukood:

Kuid numbrilise väärtuse korral läbib valideerimine edukalt:

Nõuetekohase valideerimise tagamiseks saame vastavalt värskendada ka teisi meetodikäsitlejaid:

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

Nüüd oleme taganud parima praktika meie rakendusse (võib-olla välisest allikast) jõudvate andmete kinnitamiseks mis tahes ajahetkel.

Järeldus

Sellest juhendist saate teada ploki Node.js uusima lapse kohta; Nest.js ja kõik, mis on vajalik, et aidata teil alustada, kui soovite sellega rakenduse luua. Olete õppinud, mis on Nest, selle funktsioonid, kuidas luua Nesti projekti, kuidas käsitleda Nesti rakendusse sissetulevaid andmeid ja kuidas sissetulevaid andmeid valideerida. Kokkuvõttes olete õppinud tundma mis tahes Nesti rakenduse ehitusplokke ja väärtust, mida iga komponent Nest.js-i rakendusele annab.

Sellest hetkest alates on Nestiga ettevõttetasemel rakenduse loomisel veel nii mõndagi õppida, kuid olete suutnud edukalt katta põhikontseptsioonid, mis aitavad teid kõige ees ootava juurde tööle panna.

Vaadake tulevikus uut juhendit, kus õpime Nesti ja MySQL-iga rahustavat API-t looma.

Tänud lugemise eest!

Täiendavad ressursid

Nest.js Docs
Angular Docs