Nest.js Kılavuzu – Nest ve Node ile REST API Oluşturma

Bir Node.js arka uç geliştiricisi olarak, Node.js'nin varsayılan olarak çok basit bir yapıya sahip olduğunu ve bir uygulama oluştururken neye ihtiyacınız olduğuna dair hiçbir varsayımda bulunmadığını kabul edeceksiniz. Sonuç olarak, yönlendirmeyi yönetmek, API çağrıları yapmak, TypeScript veya Web Soketlerini ayarlamak ve hatta kod organizasyonu, dosya yapısı ve adlandırma kuralları gibi temel şeyler de dahil olmak üzere bir uygulamada kullanmak istediğiniz her şeyi ayarlamaktan siz sorumlusunuz. .

Büyük ölçekli bir uygulamayı yönetmek, özellikle açık bir yapı ve katı kod düzenleme yönergeleriyle tasarlanmamışsa zor bir iş olabilir.

Nest.js, Node.js çevresinde bir soyutlama oluşturarak bu sorunlardan bazılarını çözmeye çalışır; böylece geliştirici olarak diğer küçük uygulama ayrıntıları yerine uygulama sorununa odaklanabilirsiniz.

Bu kılavuzda, Nest.js'nin yardımıyla kısa sürede kurumsal düzeyde Node.js uygulamaları oluşturabilmeniz için sizi hızlandırmayı amaçlayan Nest.js'nin temel temellerini baştan sona öğreneceksiniz.

Bu rehber aracılığıyla öğreneceğimiz her şey artarak devam edecek; giriş kavramlarına ilişkin birçok zemini kapsıyor. Bu kılavuzdan en iyi şekilde yararlanmak için kodlama yapmanıza yardımcı olur.

Haydi hemen dalalım millet!

Nest.js nedir?

Nest.js'yi, zor görevleri, araçları ve ortak kodları ortadan kaldırırken aynı zamanda modern JavaScript ve TypeScript kullanarak uygulama geliştirmeniz için tam teşekküllü bir araç seti ekleyen Node.js'nin bir üst kümesi olarak düşünün.

Nest.js, geliştiricilerin ve ekiplerin toplulukta kolayca bulunabilen ve göze çarpan seçeneklerden ve modüllerden yararlanarak yüksek düzeyde ölçeklenebilir, test edilebilir, gevşek bağlı ve bakımı kolay oluşturmasına olanak tanıyan, kullanıma hazır bir uygulama mimarisi sağlar. Express.js uygulamaları. Fastify için Express'i (varsayılan olarak başlık altında kullanır) bile değiştirebilirsiniz, ancak bunu yapmak, uygulamanızda farklı Fastify uyumlu kitaplıklar kullanmanız gerekebileceği anlamına gelir.

İşlevsel Programlama, Nesne Yönelimli Programlama ve İşlevsel Reaktif Programlamanın özelliklerini birleştirir ve üzerinde 52.4 binden fazla yıldız ve 6.2 bin çatal bulunur. GitHub Haftalık indirme sayısı 1,784,004'e ulaşan aşamalı Node.js çerçevesi, verimli, ölçeklenebilir ve kurumsal düzeyde sunucu tarafı uygulamalar oluşturmak için popüler bir tercihtir.

Nest.js'nin özellikleri

Nest.js'nin bu kadar popüler bir Node.js çerçevesi haline gelmesinin nedenleri şunlardır:

1. Nest.js, geliştiricilerin hem yekpare uygulamalar hem de mikro hizmetler oluşturmasına yardımcı olmak için oluşturuldu.
2. Güçlü olmasına rağmen aynı zamanda geliştirici dostudur; Kullanımı kolay, öğrenmesi hızlı ve uygulaması kolaydır.
3. TypeScript'ten (JavaScript'in bir üst kümesi) yararlanır ve geliştiricilere, çalışma zamanı hatalarından arınmış, bakımı yapılabilir kodlar yazmaları için yer açar.
4. Geliştiricilerin üretkenliğini ve geliştirme kolaylığını artırmaya yardımcı olan bir Komut Satırı Arayüzüne sahiptir.
5. Nest.js ile derleme yaparken, ister Minimum Uygulanabilir Ürünü önyüklüyor olun ister bir uygulama üzerinde çalışıyor olun, geliştirme süreçleri iyileştirilir ve zamandan tasarruf edilir; çünkü Nest varsayılan olarak harika bir proje klasörü yapısıyla birlikte gelir.
6. TypeORM, GraphQL, günlük kaydı, doğrulama, Mongoose, WebSockets, önbelleğe alma vb. gibi ortak kavram ve teknolojilerin entegrasyonuna yardımcı olan çeşitli Nest'e özgü modülleri destekler.
7. Nest.js, mevcut herhangi bir çerçeve için en iyi belgelerden bazılarına sahip olmakla övünebilir. Dokümantasyonu kapsamlıdır, anlaşılması kolaydır ve bir soruna çözüm bulunması gerektiğinde zahmetsizce ortaya çıktığı için hata ayıklama süresinden tasarruf etmenize yardımcı olur.
8. Nest.js, uygulamalarınıza birim testleri yazmayı kolaylaştıran Jest ile entegre olur.
9. Hem küçük hem de büyük ölçekli kurumsal uygulamalar için üretilmiştir.

Nest.js Projesi Oluşturma

Yerel makinenizde Nest.js'yi kullanmaya başlamak için öncelikle yeni bir Nest.js proje klasörü oluşturmanıza ve klasörü bir proje için gereken çekirdek dosyalar ve modüllerle doldurmanıza yardımcı olacak Nest Komut Satırı Arayüzünü (CLI) yüklemeniz gerekir. Nest.js uygulaması.

Nest.js Komut Satırı Arayüzünü yüklemek için aşağıdaki komutu çalıştırın:

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

Nest.js CLI'yi yerel makinenize global olarak başarıyla yükledikten sonra çalıştırabilirsiniz. nest Kullanabileceğimiz çeşitli komutları görmek için komut satırında:

$ nest

Sonuçlar Giriş:

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

Burada komutları nasıl kullanacağınız gösterilir ve artık new|n [options] [name] İlk Nest.js projenizi oluşturma komutu:

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

Daha sonra hangi paket yöneticisini kullanmak istediğiniz sorulacaktır:

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

İstediğiniz paket yöneticisini seçmekten çekinmeyin, ben de onunla gideceğim pnpm. Bunun nedeni, NPM'den yaklaşık üç kat daha verimli ve daha hızlı olması ve hızlı bir önbellek sistemiyle PNPM'nin Yarn'dan da daha hızlı olmasıdır.

Paket yöneticisini seçtikten sonra kurulum işlemine devam edilir ve ardından Nest.js uygulaması oluşturulur.

Şimdi yapabilirsin cd yeni oluşturulan projeye girin ve onu seçtiğiniz bir düzenleyiciyle açın:

$ cd getting-started-with-nestjs

Artık projeyi oluşturduğumuza göre, onu aşağıdaki komutlardan biriyle çalıştırabiliriz:

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

Bir bakarsan package.json dosyasının komut dosyası bölümünde değerini göreceksiniz. pnpm run start is nest start:

    
"start": "nest start",

Bu, Nest.js uygulamasını aşağıdakileri çalıştırarak da çalıştırabileceğiniz anlamına gelir:

$ nest start

Nest.js Proje Yapısına Bir Bakış

Bir Nest uygulamasının nasıl yapılandırıldığına yakından bakalım:

/package.json

The package.json dosya Node.js'nin ve uzantısı olarak Nest.js projesinin kalbidir. Projeyle ilgili tüm meta verileri tutar ve uygulama bağımlılıklarını yüklemek veya proje komut dosyalarını çalıştırmak için gereken projenin çeşitli işlevsel özelliklerini tanımlar.

Yeteneğini zaten gördük. start komut.

The start:dev profile, uygulamayı durdurup yeniden başlatmaya gerek kalmadan uygulamadaki değişiklikleri izlemeyi ve uygulamayı otomatik olarak yeniden yüklemeyi mümkün kılar ve geliştirme amaçlıdır. start:prod komut dosyası, uygulamanızın üretime hazır olup olmadığını test etmek istediğinizde ve bunu üretime dağıttığınızda Nest.js uygulamasını test etmeye yönelik diğer komut dosyalarıyla birlikte kullanışlıdır.

@nestjs/platform-express Express'i bir Nest uygulamasında varsayılan HTTP sunucusu olarak tanımlar.

/tsconfig.json

The tsconfig.json dosyası, Nest uygulamasını derlemek için gereken TypeScript ile ilgili seçenekleri tanımlayan, JSON'da (JavaScript Nesne Gösterimi) yazılmış bir dosyadır.

/nest-cli.json

Bu, Nest uygulamalarını oluşturmak, düzenlemek veya dağıtmak için gereken meta verileri içerir.

/test

Bu dizin, Nest testlerini çalıştırmak için gereken tüm dosyaları içerir. Nest, Jest yapılandırmasını test etmek için Jest çerçevesini kullanır. jest-e2e.json dosyası.

/src

The src dizin, Nest projesinin çekirdeğinin ana klasörüdür. Tutar main.ts Nest uygulamasının başladığı dosya olan dosya. İşinin main.ts dosya yüklenecek AppModule ithal edilen /src/app.module.ts.

Bu kılavuzun ilerleyen kısımlarında Modüller hakkında bilgi edineceğiz; Nest.js uygulamasının ana bileşenlerinden biri.

The AppModule kullanılarak modül olarak oluşturulan bir sınıftır. @Module dekoratör. İçinde app.module.ts dosyası, AppService itibaren ./app.service ve AppController itibaren ./app.controller da ithal edilmektedir.

The AppController aynı zamanda kullanılarak oluşturulan bir sınıftır. @Controller dekoratör, bu arada AppService kullanılarak oluşturulan bir sınıftır. @Injectable Ek açıklama.

Nest'in güzel yanı, herhangi bir sınıfa meta veri ekleyen çok az sayıda dekoratörün bulunması ve meta verilerin o sınıfın amacını tanımlamasıdır:

• @Controller()Bir sınıfı denetleyiciye dönüştürür.
• @Module() Bir sınıfı modüle dönüştürür.
• @Injectable() bir sınıfı sağlayıcıya dönüştürür.

Ayrıca src dizin şu app.controller.spec.ts Denetleyiciler için bir test dosyası olan dosya.

Uygulamayı kullanarak çalıştırabiliriz nest start.

Uygulama şu saatte başlıyor: http://localhost:3000 tarayıcınızda:

Şurada gösterilen içeriği değiştirebiliriz: http://localhost:3000, şuraya giderek app.service.ts Dizin yolu sağlayıcısının tanımlandığı dosya.

Nest.js Uygulamasının Yapı Taşları

Nest.js uygulamasının üç ana bileşeni vardır:

1. Modüller
2. Kontrolörler
3. sağlayıcılar

Bir Nest uygulamasının yapı taşlarını öğrenirken öncelikle Nest projesini temizleyelim. app.controller.spec.ts, ./app.service, app.module.ts, ve ./app.controller Dosyalar; sadece ayrılıyorum main.tssıfırdan bir geliştirme yaşam döngüsünü taklit etmek.

Bu noktada içe aktarılanları kaldırdığımızda AppModule dosyasını main.ts'Modül' için bir bağımsız değişkenin sağlanmadığı uyarısı alıyoruz.

Bir Nest uygulamasının yapı taşlarını göstermek için, bir nesne üzerinde CRUD işlemlerini gerçekleştirecek bir REST API oluşturarak basit bir Kullanıcı Profili uygulamasına göz atacağız.

Modüller

içinde src klasör yeni oluştur app.module.ts dosya oluşturun, ardından bir AppModule ihraç ettiğimiz sınıf.

Ardından, içe aktarın AppModule sınıfa girmek main.ts, ve koş nest start.

Şu yöne rotayı ayarla http://localhost:3000 tarayıcınızda bir 404 hatası alacaksınız:

Bunun nedeni, Nest uygulamasının temel URL'si için henüz bir rota tanımlamamış olmamızdır.

Back app.module.ts, bizde var AppModule Sahip olduğumuz sınıf henüz bir Nest modülü değil. Bunu bir Nest modülü yapmak için şunu ekliyoruz: @Module() ithal edilen dekoratör @nestjs/commonsonra boş bir nesnenin yanından geçiyoruz.

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

export class AppModule {}

Artık bir Nest.js modülümüz var!

The @Module() dekoratör, geliştiricilerin Nest uygulamasında bir sınıfla ilgili meta verileri tanımlamasına olanak tanır.

Kullanıcılar modülü, siparişler modülü, sohbet modülü vb. gibi birden fazla modülün olması durumunda, app.module.ts Nest uygulamasının diğer tüm modüllerini kaydetmek için kullanılmalıdır.

Rota Oluşturma; Kontrolörler

Nest uygulamalarında rota oluşturmak için denetleyicilere ihtiyaç vardır. Denetleyicinin amacı, bir Nest uygulaması için belirli istekleri almaktır; uygulama içindeki çeşitli yollar için istek ve yanıt döngüsünün kontrol edilmesi.

İstemciden Nest uygulamasına bir HTTP isteği yapıldığında, isteğin yapıldığı rotayla eşleşen rota, isteği işler ve uygun yanıtı döndürür.

Nest uygulamasında bir denetleyici oluşturmak için @Controller() dekoratör.

içinde src dizin, yeni bir dosya oluştur app.contoller.tsve burada bir Nest denetleyicisini tanımlayabiliriz:

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

@Controller({})

export class AppController {}

İşte bu! Oldukça güzel bir kumandamız var ancak yeni bir rota oluşturmak için öncelikle Nest uygulamamıza oluşturulan kumandayı bildirmemiz gerekiyor.

Bunu başarmak için mutlaka ithalat yapıyoruz AppController app.module.ts dosyasında kontrolörler hakkındaki bilgileri tanımlayın @Module() dekoratör – bir denetleyici dizisi olarak:

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

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

export class AppModule {}

GET İsteklerini İşleme

Daha sonra basit bir tanım yapıyoruz. getUser() rota (ile @Get() HTTP GET isteklerini belirli bir yola işlemek için kullanılan dekoratör) temel yol olarak hizmet vermek üzere kullanırsak, aynısına tarayıcıdan da erişebiliriz. https://localhost:3000:

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

@Controller({})

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

Bunun sonucu:

Hmm, burada sadece bir dize döndürüyoruz, peki ya bir nesne döndürmek istersek? Bir dize yerine bir nesne tanımlayabiliriz:

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

@Controller({})

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

Şu yöne rotayı ayarla http://localhost:3000 tarayıcınızda nesneyi göreceksiniz:

Temel rotanın uzağında buna benzer bir rota oluşturmaya ne dersiniz? http://localhost:3000/user tüm kullanıcıları getirmek için mi?

Böyle bir rotayı yönetecek bir denetleyiciyi birkaç şekilde oluşturabiliriz.

Bunun bir yolu, aşağıdakileri kullanarak yeni bir yöntem tanımlamak olabilir: @Get() dekoratör/işleyici.

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

@Controller({})

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

Nest.js, aşağıdakiler de dahil olmak üzere çeşitli HTTP yöntemlerinin tümü için dekoratörler veya işleyiciler sağlar: @Get(), @Post(), @Put(), @Delete(), @Patch(), @Options(), ve @Head().

The @All() dekoratör, çeşitli yöntemlerin tümünü işleyen bir uç noktayı tanımlar.

POST İsteklerini İşleme

Veritabanında veri depolamak için POST isteklerini de tanımlayabiliriz. @Post() dekoratör:

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

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

Daha sonra Postman'ı kullanarak POST isteğini test ediyoruz ve dizenin tanımlandığı gibi başarıyla döndürüldüğünü fark ediyoruz.

Verileri döndürmekten daha fazlasını yapmak istersem ne olur diye sorabilirsiniz. Belki veri göndermek için.

Bunun için, gösterildiği gibi rota yönteminin içine verileri enjekte etmeniz gerekir:

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

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

Artık POST isteğini Postman ile test ettiğimizde gönderilen verileri görüntüleyebiliyoruz. Bu durumda, bu yalnızca boş bir nesnedir:

Rota Parametreleriyle Dinamik Yönlendirme

Bir isteğin parçası olarak dinamik verileri kabul etmek istediğinizi varsayalım. Rota/URL üzerindeki dinamik konumu not etmek için öncelikle rota yolunda belirteci tanımlamamız gerekir, ardından @Param() dekoratörde rota parametresine şu şekilde erişilebilir:

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

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

The userId başarıyla döndürülür:

Eşzamansız İstekleri İşleme

Nest.js, çeşitli yaklaşımlar kullanarak bir söz döndüren eşzamansız istekleri işleyebilir:

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

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

Yukarıdaki yaklaşımda, eşzamansızlık şu şekilde ele alınır: async anahtar kelime. Diğer bir yaklaşım ise RxJS gözlemlenebilir akışlarını döndürmektir:

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

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

Burada Nest.js, alt kısımdaki kaynağa abone olacak ve akış tamamlandığında, yayılan son değeri otomatik olarak alacaktır.

Nest'te Yönlendirmeleri İşleme

The @Redirect() Dekoratör, yanıtı farklı bir URL'ye yönlendirmek için kullanılır. @Redirect() Dekoratör iki argümanı kabul eder: Yönlendirilecek URL ve yönlendirme sonrasındaki durum kodu; bunların her ikisi de isteğe bağlıdır:

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

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

Durum Kodunun Döndürülmesi

Nest.js sunucusunda işlenen herhangi bir isteğin durum kodunu döndürmek için @HttpCode(…) kolayca gelir.

Nest'te GET istekleri için varsayılan durum kodu 200, POST isteği 201, hata isteği 304'tür.

Bir sunucu isteğinin durum kodu aşağıda gösterildiği gibi tanımlanabilir:

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 İsteklerini İşleme

POST isteğinde bulunmaya benzer şekilde, silme isteği de şu şekilde gerçekleştirilebilir:

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

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

GÜNCELLEME İsteklerini İşleme

Sunucudaki belirli verileri güncelleme isteği, aşağıdakiler kullanılarak yerine getirilebilir: @Patch() dekoratör:

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

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

Artık, genellikle sağlam bir sunucuda kullanacağımız tipik denetleyicileri tanımlamanın çeşitli yollarını gördüğümüze göre, denetleyicinin yalın, temiz ve kullanım durumuna göre tanımlanmış olması gerektiğine dikkat etmek önemlidir; öyle ki, tanımlamak için başka bir denetleyici varsa user rotalar kullanılıyorsa, ayrı bir dizin oluşturulmalı ve aynı rotanın yönetilmesi için tahsis edilmelidir; AppController.

Daha sonra user.controller.ts, buradaki tüm rota işleyicilerini önek olarak yapılandırabiliriz /user/ aşağıda gösterildiği gibi kod yazarak:

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

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

Daha sonra kayıt olun UserController denetleyicilerin dizilerinde 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 {}

Şuraya gittiğimizde https:localhost:3000/userbaşarıyla döner:

Proje klasörünü şu anda olduğundan daha düzenli tutmak için bir tanımlayabiliriz. user.module.ts tanımlayacağımız dosya UserController:

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

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

export class UserModule {}

Ardından, içe aktar UserModule içine 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 {}

Böylece daha önce olduğu gibi aynı etkiyi elde edebileceğiz.

sağlayıcılar

Kullanıcıya yönelik kod ile potansiyel olarak hassas verilerle etkileşime giren kod arasında bir soyutlama katmanı oluşturmak için, bir veritabanından tüm veri alma işlemleri denetleyiciler yerine sağlayıcılar tarafından gerçekleştirilmelidir. Bu katmanlar arasında, veritabanının uygun şekilde işlenmesini sağlamak için doğrulama ayarlanabilir. Nest CLI ile hizmetler üreterek sağlayıcılar oluşturabiliriz:

$ nest g s user

Bu bir oluşturur UserService burada tüm iş mantığını tanımlayacağız UserControllerBöylece UserController yalnızca istekleri ve yanıtları işler. İçinde user.service.ts, görüyoruz ki @Injectable() Dekoratör sınıfı tanımlamak için kullanılır. Nest'te kullanımı @Injectable() dekoratörün amacı hizmetleri, depoları veya yardımcı sınıfını bir sağlayıcıya dönüştürmektir.

Sağlayıcılar, yapıcısı aracılığıyla bir sınıfa enjekte edilir. Bir örneğe yakından bakalım.

Daha önce, içinde user.controller.ts, kullanıcı nesnesini almak için iş mantığını tanımlamıştık, ancak şimdi aynısını UserService:

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

@Controller({})

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

Sonra, içinde user.controller.ts dosyasında bir yapıcı tanımlayalım. UserController sınıf. Bu yapıcıda özel bir şey sağlıyoruz userService, bir tür olan UserService sınıf. Kullanıcıları getirmek için daha önce tanımladığımız iş mantığından bu özel bilgiyle yararlanabiliyoruz:

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

Böylece, UserController sınıf, şimdi bağlıdır UserService olarak bilinen bir kavramdaki sınıf
bağımlılık enjeksiyonu.

Aynı şekilde her ikisinde de mantık user.controller.ts ve user.service.ts dosyalar buna göre güncellenir:

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

Şimdi Postman'ı kullanarak uç noktaların olması gerektiği gibi çalıştığını doğrulayalım.

Nest.js'de Bağımlılık Enjeksiyonunun Gizemini Ortaya Çıkarma

Bir uygulamanın sınıf veya modül gibi daha küçük bileşenlerini oluştururken, sınıfınız başka bir sınıfın veya modülün işlevselliğine bağlı olabilir; örneğin, API çağrıları yapmak için farklı bir sınıf tarafından sağlanan bir HTTP hizmetinden yararlanma ihtiyacı veya Kalıcılık katmanıyla etkileşime giren hizmet katmanları.

Bağımlılıklar denetleyiciler içerisinde şu şekilde sağlanabilir: bağımlılık ekleme.

Bağımlılık enjeksiyonu, bir uygulamanın parçalarının, uygulamanın onları gerektiren diğer bölümlerine, yüksek uyum ancak gevşek bağlantı sağlayacak şekilde nasıl iletildiğini ifade eden bir programlama konsepti ve modelidir.

Nest, bağımlılık enjeksiyonunu destekler ve projenizin modülerliğini geliştirmek için bunu Nest uygulamalarınızda kullanabilirsiniz.

Pratik bir örnek şu şekilde tasvir edilmiştir:

A sınıfının B sınıfının bazı işlevlerini kullandığını varsayalım. O zaman A sınıfının B sınıfına bağlı olduğu söylenir. Bu nedenle, B sınıfını A sınıfında kullanmak için önce B sınıfının bir örneğini oluşturmamız gerekir (yani bir B sınıfı örneği oluşturmamız gerekir). B Sınıfı nesnesi): const b = new B ().
Bir sınıfın örneğini oluşturma görevinin başka bir sınıfa aktarılması ve sağlanan sınıftaki bağımlılığın (enjektör bileşeni) doğrudan kullanılması, bağımlılık enjeksiyonu olarak bilinir.

Tipik olarak bir sınıf, ihtiyaç duyabileceği veya gerektirmediği çeşitli nesneleri oluşturmak için kullanılmak yerine yalnızca işlevlerini yerine getirmeye odaklanmalıdır.

Bağımlılık Enjeksiyonunun Faydaları.

1. Birim testine yardımcı olur.
2. Bağımlılık enjeksiyonu ile bağımlılıkların başlatılması enjektör bileşeni tarafından yapıldığından standart kod azaltılır.
3. Bir uygulamayı genişletme süreci daha kolay hale gelir.
4. Bağımlılık enjeksiyonu, gevşek bağlantının etkinleştirilmesine yardımcı olur.

İstek Yüklerini Keşfetme

POST ve PATCH gibi çeşitli istek işleyicilerde, sunucu tarafından gönderilen isteğe @Req() dekoratör. Ancak bundan daha fazlası var.

İstek nesnesinin tamamını almak yerine, istek nesnesinin ihtiyacımız olan belirli bölümlerine dokunabiliriz.
Bu nedenle Nest, Express of Fastify nesnelerine erişmek için HTTP rota işleyicileriyle birlikte kullanılabilecek çeşitli dekoratörler sağlar:

Yuva dekoratörleri	Erişilen Fastify veya Express nesnesi
`@Request(), @Req()`	'talep'
`@Response(), @Res()`	'yeniden'
`@Sonraki()`	'sonraki'
`@Oturum()`	'req.session'
`@Param(param?: dize)`	"req.params" / "req.params[param]"
`@Gövde(param?: dize)`	"req.body" / "req.body[param]"
`@Sorgu(param?: dize)`	"req.query" / "req.query[param]"
`@Başlıklar(param?: dize)`	"req.headers" / "req.headers[param]"
`@Ip()`	'req.ip'
`@HostParam()`	"req.hosts"

Tipik bir örnek, @Req() sonucun gövdesine erişmek için daha önce kullandığımız dekoratör @Body() bu bize zaten bir isteğin gövdesine detaya girmeden doğrudan erişim sağlayabilir:

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

Bazı durumlarda bir istek yükünün yalnızca belirli özelliklerini almak isteyebilirsiniz. Bu durumda bir Veri Aktarım Nesnesi (DTO) şeması tanımlamanız gerekir. Veri Aktarım Şeması, alınan nesnenin bir kopyasını tanımlayan bir nesnedir, ancak öncelikle kaydedilmesi veya alınması gereken nesne ile kalıcılık katmanı arasındaki verileri aktarmak için kullanılır. Genellikle bu süreç saldırılara karşı daha savunmasız olduğundan DTO çok fazla hassas veri noktası içermez. Bu özellik aynı zamanda bir nesnenin yalnızca belirli alanlarını almanıza da olanak tanır.

Derleme sırasında sınıfların değeri korunduğundan Nest'te bir Veri Aktarım Nesnesi tanımlamak için sınıfların kullanılması önerilir.

İsteğin gövdesinin bir belirteci olduğunu ve bu tür verileri almak veya güncellemek istemediğinizi varsayarsak, bir DTO aşağıda gösterildiği gibi tanımlanabilir:

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

Ancak, türü tanımladığımızı fark edeceksiniz. updateUserDto iki kere; içinde user.service.ts ve user.controller.ts, ancak kodlarımızı KURU (Kendinizi Tekrar Etmeyin) tutmamız gerekiyor ki kod tabanı etrafında kendimizi tekrarlamayalım.

Bunun için yeni bir klasörde /user/dto içinde /user dizinde bir dosya oluşturmamız gerekiyor /update-user.dto.ts ile .dto.ts tanımladığımız ve dışa aktardığımız uzantı UpdateUserDto kullanılmak üzere sınıf user.service.ts ve user.controller.ts dosyaları:

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

Boru ve Doğrulama

Sunucu üzerinden bir istek yapıldığında alınan verilerin doğrulanması gerektiğini varsayalım.

Nest'te, iki bağımlılık kurarak boruları kullanarak uygulamaya giren veya çıkan herhangi bir verinin doğruluğunu test edebiliriz: class-validator ve class-transformer.

Pipe, ile tanımlanan bir sınıftır. @Injectable() uygulayan dekoratör (dolayısıyla borular sağlayıcılardır) PipeTransform arayüz. Verileri istenilen formata dönüştürürler ve verileri öyle değerlendirirler ki, eğer veri geçerli bulunursa değişmeden geçer, aksi takdirde bir istisna atılır. Bir kanal kullanmak için belirli bir kanal sınıfının bir örneğini uygun bağlama bağlamanız gerekir.

The class-validator paket, dekoratörleri ve dekoratör olmayanları doğrulamayı mümkün kılar. doğrulayıcı.js dahili olarak. iken class-transformer paket, nesneleri bir sınıfın örneğine dönüştürmeyi, sınıfı nesneye dönüştürmeyi ve belirli kriterlere göre nesneleri serileştirmeyi veya seri durumdan çıkarmayı mümkün kılar.

Nest tarafından sağlanan sekiz boru şunlardır:

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

Bu kılavuzda Nest'te doğrulamayı göstermek için yerleşik ValidationPipe Bu, istek yüklerinde doğrulamanın uygulanmasını mümkün kılar ve aşağıdaki özelliklerle iyi bir şekilde birleşir: class-validator paket; belirli kurallar, her modüldeki Veri Aktarım Nesnesi/yerel sınıf bildirimlerinde basit açıklamalarla bildirilir.

Yerleşik özelliği kullanmaya başlamak için ValidationPipe hangi ülkeden ihraç ediliyor @nestjs/common, kurulumu yapalım class-validator ve class-transformer paketleri:

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

Ardından, adresine gidin. main.ts nereye bağlayacağız ValidationPipe Uygulamamızdaki tüm uç noktaların geçersiz veri alımına karşı korunmasını sağlamak için uygulamanın kök düzeyinde:

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

Daha sonra, her modülün Veri Aktarım Nesnesi bildirimlerine, her bir veri için uygun veri kontrollerini bildirerek birkaç doğrulama kuralı ekliyoruz. Bizim durumumuzda, uygun doğrulama kurallarını beyan ederiz. name ve email in UpdateUserDto:

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

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

  @IsEmail()
  email: string;
}

The @IsString() Dekoratör, belirli bir verinin gerçek bir dize olup olmadığını kontrol eder ve @IsEmail() doğrulayıcı, belirli bir verinin bir e-posta olup olmadığını kontrol eder, aksi takdirde false değerini döndürür ve bir istisna atar.

Şimdi, eğer bir şey yapmaya çalışırsak PATCH Bir kullanıcı profiline istekte bulunun ve geçerli bir e-posta yerine bir sayı girin; örneğin, bir istisna atılacaktır:

Bunlarla Nest uygulamamızda çok güzel bir doğrulamaya sahip oluyoruz.

İle doğrulama yaparken ValidationPipe, yöntem işleyicimizin almasını istemediğimiz özelliklerimizi de filtrelememiz mümkündür. Örneğin, eğer işleyicimiz yalnızca şunu bekliyorsa name ve email özellikler, ancak bir istek aynı zamanda bir country özelliği kaldırabiliriz country ayarlayarak elde edilen nesneden özellik whitelist için true somutlaştırdığımızda 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();

Yöntem Parametre Düzeyinde Boruların Bağlanması

Borular ayrıca tanımlanabilir. params, ilave olarak. Bunun için pipe'yi metodun param seviyesinde bağlayacağız.

Daha önce tanımlamış olsak da userId bir sayı olmak için, şunu fark edeceksiniz ki, eğer bir talepte bulunursak userId bir dize olarak ne olursa olsun başarılı olur:

Değerinin garanti altına alınması için userId her zaman bir sayı olmalıdır, bunun bağlayıcı olduğunu beyan edeceğiz getUser() aynısını sağlayan bir doğrulama kontrolüne sahip yöntem işleyicisi:

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

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

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

The ParseIntPipe Yerleşik ParseInt Pipe'ı tanımlar ve çalıştırıldığı verilerin bir tamsayı olmasını sağlar.

Şimdi, bir şey yaptığımızda GET geçersiz bir istek userId "ab" dizesinin geçerli olması durumunda doğrulama başarısız olur ve bir istisna atılır. 400 durum kodu:

Ancak sayısal bir değerle doğrulama başarıyla geçer:

Doğru doğrulamayı sağlamak için diğer yöntem işleyicilerini de buna göre güncelleyebiliriz:

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

Artık, uygulamamıza herhangi bir zamanda harici bir kaynaktan giren verileri doğrulamak için en iyi uygulama tekniğini sağladık.

Sonuç

Bu kılavuzda Node.js bloğundaki en son çocuk hakkında bilgi edinebildiniz; Nest.js ve onunla bir uygulama oluşturmak istiyorsanız başlamanıza yardımcı olacak her şey. Nest'in ne olduğunu, özelliklerini, Nest projesinin nasıl oluşturulacağını, Nest uygulamasına gelen verilerin nasıl işleneceği ve gelen verilerin nasıl doğrulanacağını öğrendiniz. Toplamda herhangi bir Nest uygulamasının yapı taşlarını ve her bir bileşenin Nest.js uygulamasına kattığı değeri öğrendiniz.

Bu noktadan itibaren, Nest ile kurumsal düzeyde bir uygulama oluşturmaya ilişkin öğrenilecek hâlâ çok şey var, ancak sizi önünüzde uzanan her şeye hazır hale getirebilecek temel kavramları başarılı bir şekilde ele almayı başardınız.

Gelecekte Nest ve MySQL ile rahat bir API oluşturmayı öğreneceğimiz yeni bir kılavuza dikkat edin.

Okuduğunuz için teşekkür ederim!

Ek kaynaklar

Nest.js Dokümanları
Açısal Belgeler