🎞️ 📭 🧔🏼 Temui NestJS ⌨️ 🚣 🥇

Sebuah terjemahan dari artikel itu dipersiapkan menjelang peluncuran Pengembang Node.js saja .

Pengembang modern memiliki banyak alternatif dalam hal menciptakan layanan web dan aplikasi server lainnya. Node telah menjadi pilihan yang sangat populer, namun, banyak programmer lebih suka bahasa yang lebih kuat daripada JavaScript, terutama yang berasal dari bahasa berorientasi objek modern, seperti C #, C ++ atau Java. Jika TypeScript hanya cocok untuk NodeJS , maka kerangka kerja NestJS membawanya ke tingkat yang sama sekali baru, menyediakan alat modern untuk pengembang backend untuk membuat aplikasi yang tahan lama dan berkinerja tinggi menggunakan komponen, penyedia, modul, dan abstraksi tingkat tinggi lainnya yang bermanfaat.

Pada artikel ini, kita akan melihat proses pembuatan server API sederhana di NestJS untuk memproses skenario aplikasi dasar: membuat, menyimpan, dan mengambil daftar produk supermarket.
Jika Anda ingin membiasakan diri dengan kode sumber proyek, Anda dapat menemukannya di sini .

Pembuatan proyek

Untuk bekerja dengan Nest, Anda memerlukan lingkungan Node. Jika Anda belum memilikinya, buka situs web mereka dan unduh.

Menginstal frameworknya cukup sederhana:

$ npm i -g @nestjs/cli

Proyek ini dibuat menggunakan Nest CLI setelah menjalankan perintah berikut:

$ nest new nest-js-example

Tim semacam itu akan membuat proyek Nest yang sama sekali baru dengan file konfigurasi yang diperlukan, struktur folder dan template server.

Titik masuk aplikasi

File utama yang mengkonfigurasi dan memulai server adalah src/main.ts:

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

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

bootstrap();

File ini mengimpor kelas NestFactory , yang digunakan untuk membuat aplikasi, dan file AppModule utama (yang akan segera kita temui), dan kemudian mengunduh aplikasi, membuat instance, dan mendengarkan pada port 3000.

Modul aplikasi

File tempat komponen aplikasi dideklarasikan disebut src/app.module.ts:

import { Module } from '@nestjs/common';
import { ItemsController } from './items/items.controller';
import { ItemsService } from './items/items.service';

@Module({
    imports: [],
    controllers: [ ItemsController ],
    providers: [ ItemsService ],
})

export class AppModule {}

Ini adalah file tempat komponen lain diimpor dan dideklarasikan dalam Modul, yang diimpor dalam file sebelumnya ( main.ts ). Alat Nest CLI akan secara otomatis memperbarui file ini sesuai kebutuhan ketika diinstruksikan untuk membuat komponen baru. Di sini, pengontrol dan layanan untuk item diimpor dan ditambahkan ke modul.

Pengontrol Barang

File selanjutnya yang akan kami ulas adalah src/items/items.controller.ts:

import { Controller, Req, Get, Post, Body } from '@nestjs/common'
import { CreateItemDto } from './dto/create-item.dto'
import { ItemsService } from './items.service'
import { Item } from './items.interface'

@Controller('items')
export class ItemsController {

    constructor(private readonly itemsService: ItemsService) {}

    @Post()
    create(@Body() data: CreateItemDto): Object {
        return this.itemsService.create(data)
    }

    @Get()
    findAll(): Array<Item> {
        return this.itemsService.findAll()
    }
}

File ini mendefinisikan controller untuk membuat item dan mendapatkan daftar item yang dibuat sebelumnya. Beberapa komponen utama diimpor di sini:

CreateItemDto : Objek Transfer Data yang menentukan bagaimana data barang akan dikirim melalui jaringan (mis. Ini adalah struktur data JSON);
ItemsService: Penyedia yang menangani manipulasi atau penyimpanan data Item ;
Item : Antarmuka yang mendefinisikan struktur data internal untuk Item ;

Dekorator @Controller('items')memberi tahu kerangka kerja bahwa kelas ini akan melayani titik akhir REST / items , dan konstruktor ItemsController mengambil instance ItemsService , yang digunakan secara internal untuk melayani dua metode HTTP:

POST / item (membuat item baru dari permintaan JSON);
DAPATKAN / item (mendapatkan daftar item yang dibuat sebelumnya).

Permintaan untuk dua metode ini ditangani oleh metode create dan FindAll, yang terikat dengan metode HTTP yang sesuai menggunakan @Post()dan dekorator @Get(). Metode tambahan juga dapat didukung oleh dekorator dengan cara yang sama, misalnya, @Put()atau @Delete(), dll.

Antarmuka Objek Item

Selanjutnya, kita akan berurusan dengan dua file yang mendefinisikan antarmuka untuk menyimpan item , satu untuk penggunaan internal, seperti memeriksa jenis pada waktu kompilasi ( Item ), dan antarmuka eksternal untuk menentukan struktur yang diharapkan dari JSON yang masuk ( CreateItemDto):

export interface Item {
	
    name: string,
    description: string,
    price: number
}

export class CreateItemDto {

    @IsNotEmpty()
    readonly name: string;

    @IsNotEmpty()
    readonly description: string;

    @IsNotEmpty()
    readonly price: number;
}

Antarmuka Item mendefinisikan tiga properti produk toko reguler: nama, deskripsi, dan harga. Ini memastikan bahwa tidak ada kebingungan dalam arsitektur aplikasi mengenai apa item itu dan properti apa yang dimilikinya.

Kelas CreateItemDto mencerminkan properti Item , mendekorasi setiap properti @IsNotEmpty()untuk memastikan bahwa semua properti ini diminta oleh titik akhir REST API.

Semua properti dari kedua kelas sangat diketik, yang merupakan salah satu keunggulan utama dari TypeScript (karenanya namanya). Pada pandangan pertama, ini meningkatkan tingkat pemahaman konteks, dan secara signifikan mengurangi waktu pengembangan ketika digunakan dengan benar dengan alat analisis kode (seperti IntelliSense di VSCode). Ini terutama berlaku untuk proyek besar dengan ratusan atau bahkan ribuan kelas dan antarmuka yang berbeda. Bagi mereka yang tidak memiliki memori foto sempurna dengan kapasitas tak terbatas (misalnya, untuk saya), itu jauh lebih mudah daripada mencoba mengingat ribuan detail spesifik.

Layanan Barang

Yang terbaru adalah layanan untuk membuat dan menerima items: items.service.dart:

import { Injectable } from '@nestjs/common'
import { Item } from './items.interface'

@Injectable()
export class ItemsService {

    private items: Array<Item> = []

    create(item: Item): Object {

        this.items.push(item) 
        return { id: this.items.length.toString() }
    }

    findAll(): Array<Item> {

        return this.items;
    }
}

Kelas ItemsService mendefinisikan array sederhana dari objek Item yang akan berfungsi sebagai penyimpanan data dalam memori untuk proyek sampel kami. Dua metode yang menulis dan membaca dari repositori ini adalah:

buat (menyimpan Item ke daftar dan mengembalikan id-nya);
findAll (mengembalikan daftar objek Item yang dibuat sebelumnya ).

Pengujian

Untuk memulai server, gunakan perintah mulai menjalankan standar npm . Ketika aplikasi diluncurkan, itu dapat diuji dengan mengirimkan permintaan HTTP melalui CURL :

$ curl -X POST localhost:3000/items -d '{"name":"trinket", "description":"whatever", "price": 42.0}'

Menjalankan perintah ini akan mengembalikan respons JSON dengan id yang dihasilkan oleh item . Untuk menampilkan daftar item yang telah dibuat, gunakan:

$ curl localhost:3000/items

Permintaan GET ke / item di atas akan mengembalikan respons JSON dengan informasi tentang item yang sudah ada dalam memori. Jawabannya akan terlihat seperti ini:

[{"{\"name\":\"trinket\", \"description\":\"whatever\", \"price\": 42.0}":""}]

Kesimpulan

NestJS adalah solusi yang relatif baru di bidang pengembangan backend, dengan serangkaian fungsi besar untuk dengan cepat membangun dan menggunakan layanan perusahaan yang memenuhi persyaratan klien aplikasi modern dan mematuhi prinsip-prinsip SOLID dan penerapan dua belas faktor .

Untuk mempelajari lebih lanjut, kunjungi situs web NestJS .
Terima kasih telah membaca artikel saya. Selamat coding!

Temui NestJS