ABC NestJS:Panduan Pemula dengan MongoDB(Mongoose).

Apa itu NestJS?

NestJS adalah kerangka kerja NodeJS modern yang menggunakan kerangka kerja NodeJS populer seperti Express dan Fastify di bawah tenda. NestJS sebagian besar terinspirasi oleh Angular, dan sebagai hasilnya, ia menggunakan sistem modul bergaya Angular. NestJS ditulis dalam TypeScript, meskipun juga mendukung JavaScript asli.

Prasyarat

Untuk mengikuti tutorial ini, Anda harus memenuhi persyaratan berikut

Kompetensi dalam PostMan atau alat pengujian API lainnya.
Pengetahuan Dasar tentang NodeJS dan aplikasi Express.
Pengetahuan dasar tentang TypeScript.
Kompetensi dalam MongoDB(Mongoose).

Berikut ini harus diinstal pada sistem Anda

NodeJS v.14 dan yang lebih baru.
Kode Visual Studio(Disarankan) atau IDE lainnya.
PostMan atau Alat pengujian API lainnya.

Terminologi Umum yang digunakan di NestJS;

Berikut adalah beberapa istilah yang paling sering digunakan di NestJS yang akan sering Anda temui di artikel ini.

Antarmuka

Antarmuka adalah definisi tipe. Akibatnya, ini digunakan sebagai pemeriksa/penegak tipe dalam fungsi, kelas, dll.

interface humanInterface{
  name:string;
  gender:string;
  age:number;
}

const kevin: humanInterface={
  name:'Kevin Sunders',
  gender:'Male',
  age: 25,
}

humanInterface di atas melakukan pemeriksaan tipe yang ketat pada kevin obyek. TypeScript akan menimbulkan kesalahan jika Anda menambahkan bidang lain atau mengubah jenis properti objek apa pun.

Pengontrol

Controller bertugas menerima request yang masuk dan merespon client. Pengontrol berkolaborasi dengan layanan terkaitnya.

Layanan

Layanan adalah penyedia yang menyimpan dan mengambil data dan digunakan dengan pengontrol yang sesuai.

Dekorator

Dekorator adalah ekspresi yang mengembalikan fungsi yang menerima target , name , dan property descriptor sebagai argumen opsional. Dekorator ditulis sebagai @decorator-name . Mereka biasanya dilampirkan ke deklarasi kelas, metode, dan parameter.

@Get()
   getAll(): Model[] {
    return this.testService.getAll();
  }

@Get dekorator di atas menandai blok kode di bawahnya sebagai GET meminta. Lebih lanjut tentang itu nanti.

Modul

Modul adalah bagian dari program yang menangani tugas tertentu. Modul di NestJS ditandai dengan memberi anotasi pada kelas yang dianotasi dengan @Module() penghias. Nest menggunakan metadata yang disediakan oleh @Module() dekorator untuk mengatur struktur aplikasi.

Memasang CLI

Untuk memulai, Anda harus menginstal NestJS CLI ****dengan npm . Anda dapat melewati langkah ini jika Anda sudah menginstal NestJS CLI di sistem Anda.

npm i -g @nestjs/cli

Blok kode di atas ini akan menginstal CLI sarang secara global di sistem Anda.

Membuat proyek baru

Untuk menghasilkan proyek baru, jalankan nest new diikuti dengan nama proyek yang Anda inginkan. Untuk artikel ini, kami akan menulis API blog sederhana dengan fungsionalitas CRUD sambil mengikuti standar RESTful.

nest new Blog-Api

Perintah ini akan meminta Anda untuk memilih manajer paket, pilih npm .

Ini kemudian akan membuat perancah seluruh struktur proyek dengan titik akhir API uji yang portnya disetel ke 3000 secara default. Anda dapat mengujinya di http://localhost:3000 setelah menjalankan npm run start:dev perintah yang akan memulai server dalam mode menonton mirip dengan apa yang dilakukan nodemon di aplikasi ekspres.

Setelah menguji titik akhir, Anda harus menghapus beberapa file default karena Anda tidak akan membutuhkannya lagi. Untuk melakukan ini;

buka folder src dan di dalamnya,
hapus app.controller.spec.ts ,
hapus app.controller.ts ,
hapus app.service.ts ,
Buka app.module.ts ,
Hapus referensi ke AppController di controllers array dan impor,
Hapus referensi ke AppService di providers array dan impor.

Anda mungkin juga perlu mengubah README.md untuk memenuhi spesifikasi Anda.

app.module.ts Your Anda file akan terlihat seperti ini,

//app.module.ts

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

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

Variabel Lingkungan

Sebagai praktik yang baik, beberapa informasi sensitif dalam kode Anda tidak boleh dipublikasikan. Misalnya PORT dan MongoDB URI .

Mari kita perbaiki ini dalam kode Anda.

Di terminal Anda, jalankan

npm i dotenv

Kemudian buat .env file di direktori Anda dan tambahkan ke .gitignore . Anda mengajukan. Simpan PORT . Anda variabel, Anda juga harus menyimpan MongoDB URI nanti di tempat yang sama. Sekarang ganti PORT . yang terbuka di main.ts . Anda mengajukan. Untuk melakukannya, impor dotenv paket dan panggil .config() metode di atasnya.

import * as dotenv from 'dotenv';
dotenv.config();

Ini harus menjadi main.ts . Anda file setelah Anda mengikuti langkah-langkah di atas.

//main.ts

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import * as dotenv from 'dotenv';
dotenv.config();

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

Membuat Modul

Untuk menghasilkan modul NestJS menggunakan NestJS CLI, jalankan cuplikan kode di bawah ini.

nest generate module blogs

Perintah ini membuat blogs folder yang berisi blogs.module.ts file dan register BlogsModule di app.module.ts . Anda berkas.

Membuat Antarmuka

Mari buat antarmuka menggunakan NestJS CLI untuk melakukan pengecekan tipe untuk objek yang akan mewakili postingan blog Anda. Untuk mencapai ini, Anda harus terlebih dahulu cd ke dalam blogs folder karena direkomendasikan bahwa mereka disimpan di dekat objek domain yang terkait.

cd src/blogs

Kemudian jalankan cuplikan kode di bawah ini untuk menghasilkan antarmuka.

nest generate interface blogs

ini membuat blogs.interface.ts mengajukan. Di sinilah kita akan mendefinisikan antarmuka kita. kami akan memberi nama antarmuka BlogsInterface .

export interface BlogsInterface {
  title: string;
  body: string;
  category: string;
  dateCreated: Date;
}

sebelum menjalankan perintah lagi di terminal Anda, ingatlah untuk cd keluar dari src folder dan kembali ke folder root Anda dengan menjalankan

cd ../..

Menghasilkan Layanan &Pengontrol

Anda harus membuat kelas layanan untuk menyimpan dan mengambil data serta menangani semua logika dan kelas pengontrol untuk menangani semua permintaan masuk dan respons keluar.

Layanan

Untuk menghasilkan layanan, jalankan perintah di bawah ini,

nest generate service blogs

Perintah ini membuat dua file blogs.service.spec.ts dan blogs.service.ts dan mendaftarkan layanan di providers array di blogs.module.ts .

Pengontrol

Untuk menghasilkan pengontrol, jalankan perintah di bawah ini,

nest generate controller blogs

Perintah ini membuat dua file blogs.controller.spec.ts dan blogs.controller.ts dan mendaftarkan pengontrol di controllers array di blogs.module.ts .

Dengan ini struktur blog Anda hampir selesai, Anda hanya perlu membuat BlogsService dapat diakses oleh bagian lain dari program Anda. Anda dapat mencapai ini dengan membuat exports array di blogs.module.ts file dan mendaftarkan BlogsService dalam larik itu.

//blogs.module.ts

import { Module } from '@nestjs/common';
import { BlogsService } from './blogs.service';
import { BlogsController } from './blogs.controller';

@Module({
  providers: [BlogsService],
  controllers: [BlogsController],
  exports: [BlogsService],
})
export class BlogsModule {}

MongoDB(Luwak).

Instal luwak dengan menjalankan,

npm install --save @nestjs/mongoose mongoose

Setelah instalasi, impor {MongooseModule} dari '@nestjs/mongoose’ ke app.module.ts . Anda mengajukan. Kemudian ambil MongoDB URI dan simpan di .env . Anda mengajukan. Ulangi langkah-langkah untuk mengimpor dotenv di app.module.ts mengajukan. Kemudian di imports array memanggil .forRoot() metode yang mengambil MongoDB URI Anda sebagai argumen pada MongooseModule . Mirip dengan mongoose.connect() di aplikasi ekspres biasa.

@Module({
  imports: [BlogsModule, MongooseModule.forRoot(process.env.MONGODB_URI)],

Membuat Skema.

Mari buat skema untuk menentukan bentuk blog di koleksi kita. Untuk melakukan ini,

Buat folder di dalam blogs Anda folder, beri nama schemas ,
Di dalam schemas folder, buat file dan beri nama blogs.schema.ts .

Kemudian,

Pertama, Anda harus,

Impor prop dekorator, Schema dekorator, dan SchemaFactory dari @nestjs/mongoose ,
Buat kelas Blog dan ekspor,
Ubah kelas menjadi Skema dengan menempatkan @Schema() dekorator di atas kelas,
Buat BlogSchema konstanta , tetapkan nilai balik untuk memanggil .createForClass(Blog) dengan nama kelas Anda sebagai argumen di SchemaFactory yang Anda impor sebelumnya.

//blogs.schema.ts

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';

@Schema()
export class Blog {}

export const BlogSchema = SchemaFactory.createForClass(Blog);

Kemudian Anda harus menentukan properti Skema.

Untuk mendefinisikan properti dalam skema, Anda harus menandai masing-masing properti dengan @prop() penghias. @prop dekorator menerima objek opsi atau deklarasi tipe kompleks. Deklarasi tipe kompleks dapat berupa array dan deklarasi tipe objek bersarang.

//blogs.schema.ts

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';

@Schema()
export class Blog {
  @Prop({ required: true })
  title: string;

  @Prop({ required: true })
  body: string;

  @Prop({ required: true })
  category: string;

  @Prop({ required: true })
  dateCreated: Date;
}

export const BlogSchema = SchemaFactory.createForClass(Blog);

Selanjutnya impor { Document } dari 'mongoose' .

Kemudian buat tipe gabungan dengan kelas Skema dan Document yang diimpor . Seperti begitu,

//blogs.schema.ts

import { Document } from 'mongoose';

export type BlogDocument = Blog & Document;

blogs.schema.ts terakhir Anda file akan terlihat seperti ini,

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

export type BlogDocument = Blog & Document;

@Schema()
export class Blog {
  @Prop({ required: true })
  title: string;

  @Prop({ required: true })
  body: string;

  @Prop({ required: true })
  category: string;

  @Prop({ required: true })
  dateCreated: Date;
}

export const BlogSchema = SchemaFactory.createForClass(Blog);

Skema Pendaftaran

Anda harus mengimpor semuanya ke blogs.module.ts Anda mengajukan. Untuk mencapai ini, Anda harus,

Impor {MongooseModule} dari '@nestjs/mongoose’ ,
Impor {Blog, BlogSchema} dari './schemas/blogs.schema’
Buat imports array di dalam @module dekorator
Panggil .forFeature() metode pada MongooseModule . Ini mengambil array yang berisi objek yang mendefinisikan name dan schemas properti yang harus disetel ke Blog.name Anda dan BlogSchema . Anda masing-masing.

@Module({
  imports: [
    MongooseModule.forFeature([{ name: Blog.name, schema: BlogSchema }]),
  ],

Skema Penyuntikan

Anda harus memasukkan Blog modelkan ke dalam blogs.service.ts menggunakan @InjectModel() penghias. Untuk mencapai ini, Anda harus

impor { Model } dari 'mongoose' ,
impor { InjectModel } dari '@nestjs/mongoose’ ,
Impor {Blog, BlogDocument} dari './schemas/blogs.schema’ ,
Buat constructor di dalam BlogsService kelas,
Deklarasikan private variabel dan beri nama blogModel dan tetapkan jenis Model<BlogDocument> untuk itu. Semua metode luwak akan dipanggil pada variabel ini.

Ingat itu, BlogDocument adalah tipe gabungan dari Blog kelas dan Model Luwak yang Anda buat sebelumnya. Ini digunakan sebagai tipe generik untuk variabel Anda.

Dekorasi blogModel dengan @InjectModel() dan berikan Blog.name sebagai argumen.

constructor(
    @InjectModel(Blog.name)
    private blogModel: Model<BlogDocument>,
  ) {}

Cara Kerja Perutean

Sekarang Anda pasti telah memperhatikan bahwa @Controller dekorator memiliki string 'blogs' berlalu ke dalamnya. Ini berarti bahwa pengontrol akan mengirimkan semua tanggapan dan menangani semua permintaan yang dibuat di http://localhost/3000/blogs .

Selanjutnya Anda akan mengimplementasikan logika layanan dan pengontrol.

Logika Layanan dan Pengontrol.

Akhirnya tiba saatnya untuk mengimplementasikan fungsionalitas CRUD Anda.

Sebelum memulai, Anda harus menyiapkan pengontrol. Mulailah dengan mengimpor beberapa HTTP dekorator metode ke pengontrol Anda.

//blogs.controller.ts

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

Kemudian, Anda harus mengimpor layanan dan mendaftarkannya sehingga Anda dapat mengaksesnya dan mengimpor antarmuka untuk pemeriksaan tipe.

//blogs.controller.ts

import { BlogsInterface } from './blogs.interface';
import { BlogsService } from './blogs.service';

Untuk mendaftarkan layanan Anda, buat constructor di dalam BlogsController class dan mendeklarasikan private readonly variabel service dan atur jenisnya ke BlogsService .

constructor(private readonly service: BlogsService) {}

Sekarang setelah Anda siap, mari kita mulai.

Buat

Logika Layanan

Impor { BlogsInterface } dari './blogs.interface' dan tambahkan async fungsi ke BlogsService kelas bernama createBlog , yang akan mengambil satu parameter blogs , dengan jenisnya sebagai BlogInterface , dan jenis pengembaliannya sebagai Promise dengan <Blog> generic generik Tipe.

async createBlog(blog: BlogsInterface): Promise<Blog> {
    return await new this.blogModel({
      ...blog,
      dateCreated: new Date(),
    }).save();
  }

Logika Pengontrol

Di BlogsController . Anda kelas tambahkan async fungsi ke kelas. Sebut saja createBlog dan tandai dengan @Post dekorator yang mendefinisikannya sebagai POST permintaan.createBlog mengambil satu parameter blogs , dengan jenisnya sebagai BlogInterface . Tandai parameter dengan @Body dekorator yang mengekstrak seluruh body objek dari req objek dan mengisi parameter yang didekorasi dengan nilai body .

@Post()
  async createBlog(
    @Body()
    blog: BlogsInterface,
  ) {
    return await this.service.createBlog(blog);
  }

Baca

Tambahkan dua async metode, Satu untuk mengembalikan satu posting blog dan yang kedua untuk mengembalikan semua posting blog.

Logika Layanan

async getAllBlogs(): Promise<Blog[]> {
    return await this.blogModel.find().exec();
  }

  async getBlog(id: string): Promise<Blog> {
    return await this.blogModel.findById(id);
  }

Logika Pengontrol

  @Get()
  async getAllBlogs() {
    return await this.service.getAllBlogs();
  }

  @Get(':id')
  async getBlog(@Param('id') id: string) {
    return await this.service.getBlog(id);
  }

async fungsi ditandai dengan @Get dekorator yang mendefinisikannya sebagai GET permintaan.

async kedua dekorator fungsi memiliki argumen ':id' . Yang akan Anda berikan ke @Param penghias. Parameter ditandai dengan @Param('id') yang mengekstrak params properti dari req objek dan mengisi parameter yang didekorasi dengan nilai params .

Perbarui

Mari kita terapkan logika untuk PUT permintaan.

Logika Layanan

async updateBlog(id: string, body: BlogsInterface): Promise<Blog> {
    return await this.blogModel.findByIdAndUpdate(id, body);
  }

Logika Pengontrol

@Put(':id')
  async updateBlog(
    @Param('id')
    id: string,
    @Body()
    blog: BlogsInterface,
  ) {
    return await this.service.updateBlog(id, blog);
  }

async parameter kedua fungsi ditandai dengan @Body() dekorator yang mengekstrak seluruh body objek dari req objek dan mengisi parameter yang didekorasi dengan nilai body .

Hapus

Mari kita terapkan logika untuk delete permintaan.

Logika Layanan

async deleteBlog(id: string): Promise<void> {
    return await this.blogModel.findByIdAndDelete(id);
  }

Promise tipe generiknya adalah void karena Delete permintaan mengembalikan janji kosong.

Logika Pengontrol

@Delete(':id')
  async deleteBlog(@Param('id') id: string) {
    return await this.service.deleteBlog(id);
  }

Menguji API

Untuk menguji API ini, Anda harus menggunakan alat pengujian API. Untuk artikel ini, saya akan menggunakan alat pengujian API populer yang disebut Postman. Saya akan menggunakan data acak tentang topik populer untuk diuji.

Buat

Buat POST permintaan ke http://localhost/3000/blogs dengan objek JSON berikut, ini akan menambahkan semua data ke database Anda.

{
  "title": "jeen-yuhs",
  "body": "The life of superstar rapper Kanye West is currently streaming on Netflix - and according to our jeen-yuhs review, it's a fascinating watch. -credit:Radio Times",
  "category":"Music"
}

{
  "title": "Why You Should Always Wash Your Hands",
  "body": "Germs from unwashed hands can be transferred to other objects, like handrails, tabletops, or toys, and then transferred to another person's hands.-credit cdc.gov",
  "category":"Health"
}

{
  "title": "Why You Should Follow me on Twitter",
  "body": "Well, Because I asked nicely",
  "category":"Random"
}

Anda harus mendapatkan 201 respon dan blog yang dibuat dengan tanggal dan _id ditambahkan.

Baca

Buat GET permintaan ke http://localhost/3000/blogs . Ini akan mengembalikan

200 respons dengan larik semua data yang Anda tambahkan sebelumnya. Salin _id properti dari salah satu objek array.

Buat lagi GET permintaan ke http://localhost/3000/blogs/id dengan id yang disalin sebelumnya. Ini akan mengembalikan 200 respons dengan data objek yang id-nya digunakan untuk membuat permintaan.

Perbarui

Buat PUT permintaan ke http://localhost/3000/blogs/id dengan data di bawah ini. id harus diganti dengan yang Anda salin sebelumnya. Ini akan mengembalikan 200 respons dan perbarui objek yang memuat id di balik layar. jika Anda menjalankan GET another yang lain permintaan Anda harus mendapatkan objek yang diperbarui.

{
  "title": "why you Should Cut your Nails",
  "body": "It's important to trim your nails regularly. Nail trimming together with manicures makes your nails look well-groomed, neat, and tidy.- credit:WebMD",
  "category":"Health"
}

Hapus

Buat DELETE permintaan ke http://localhost/3000/blogs/id .Ini akan mengembalikan 200 respons dan menghapus objek yang memuat id di balik layar. jika Anda menjalankan GET another yang lain meminta Anda tidak akan melihat objek yang dihapus.

Kesimpulan

Jadi kita akhirnya di akhir artikel ini. Mari kita rekap apa yang telah Anda bahas.

Apa itu NestJS,
Terminologi di NestJS,
Membuat aplikasi NestJS,
Mengintegrasikan MongoDB ke dalam aplikasi NestJS,
Memanipulasi dan aplikasi NestJS,

Itu cukup banyak, selamat telah berhasil sejauh ini.

Anda dapat menemukan kodenya di github.

Semoga sukses dalam perjalanan NestJS Anda!