Mastering NestJS: Dari Pemula hingga Mahir dalam 10 Langkah

Daftar Isi

Pengenalan NestJS dan Arsitektur Dasar
Menyiapkan Lingkungan Pengembangan
Membuat Project NestJS Pertama
Module, Controller, dan Service
Dependency Injection dan Provider
Routing dan Request Handling
Middleware, Pipes, dan Guards
Database dengan TypeORM dan Mongoose
Testing dan Debugging Aplikasi NestJS
Deployment dan Best Practices

Langkah 1: Pengenalan NestJS dan Arsitektur Dasar

NestJS adalah framework progresif untuk membangun aplikasi server-side yang efisien dan skalabel menggunakan Node.js. NestJS dibangun dengan TypeScript dan mengadopsi arsitektur modular yang memudahkan pengembangan aplikasi yang terstruktur dan mudah dipelihara.

Arsitektur dasar NestJS terdiri dari beberapa komponen utama seperti Module, Controller, dan Service. Module berfungsi sebagai wadah untuk mengelompokkan fitur aplikasi, Controller menangani request dan response, sedangkan Service berisi logika bisnis aplikasi.

Diagram arsitektur modular NestJS yang menunjukkan hubungan antara Module, Controller, dan Service dalam aplikasi

Langkah 2: Menyiapkan Lingkungan Pengembangan

Untuk mulai menggunakan NestJS, Anda perlu menyiapkan lingkungan pengembangan yang sesuai. Berikut adalah langkah-langkah yang harus dilakukan:

Install Node.js versi terbaru dari nodejs.org .
Install npm (biasanya sudah terinstall bersama Node.js).
Install Nest CLI secara global dengan perintah npm i -g @nestjs/cli .
Siapkan editor kode seperti Visual Studio Code.

Tampilan layar komputer dengan terminal yang menunjukkan instalasi Node.js dan NestJS CLI

Langkah 3: Membuat Project NestJS Pertama

Setelah lingkungan siap, buat project NestJS pertama Anda dengan perintah berikut:

nest new nama-project

Perintah ini akan membuat folder project baru dan menginstall dependensi yang dibutuhkan. Setelah selesai, masuk ke folder project dan jalankan aplikasi dengan:

cd nama-project
npm run start

Buka browser dan akses http://localhost:3000 untuk melihat aplikasi berjalan.

Tampilan terminal yang menunjukkan perintah membuat dan menjalankan project NestJS pertama

Langkah 4: Module, Controller, dan Service

NestJS menggunakan konsep modular untuk mengorganisasi kode. Setiap fitur biasanya terdiri dari Module, Controller, dan Service.

Module: Tempat mengelompokkan komponen aplikasi.
Controller: Menangani HTTP request dan response.
Service: Berisi logika bisnis dan dapat digunakan oleh Controller.

Contoh pembuatan module, controller, dan service menggunakan CLI:

nest generate module users
nest generate controller users
nest generate service users

Dengan perintah di atas, NestJS akan membuat file dan struktur yang sesuai untuk fitur "users".

Struktur folder project NestJS yang menampilkan folder module, controller, dan service

Langkah 5: Dependency Injection dan Provider

NestJS menggunakan Dependency Injection (DI) untuk mengelola dependensi antar komponen. Provider adalah kelas yang dapat di-inject ke dalam komponen lain, biasanya berupa service.

Contoh penggunaan DI pada service:

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

@Injectable()
export class UsersService {
  getUsers() {
    return ['User1', 'User2', 'User3'];
  }
}

Kemudian inject service ini ke controller:

import { Controller, Get } from '@nestjs/common';
import { UsersService } from './users.service';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Get()
  getAllUsers() {
    return this.usersService.getUsers();
  }
}

Diagram yang menunjukkan konsep dependency injection antara controller dan service di NestJS

Langkah 6: Routing dan Request Handling

Routing di NestJS diatur oleh decorator pada controller dan method. Contoh routing dasar:

@Controller('products')
export class ProductsController {
  @Get()
  findAll() {
    return 'Daftar produk';
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return `Produk dengan id ${id}`;
  }
}

Anda dapat menggunakan decorator seperti @Get() , @Post() , @Put() , dan @Delete() untuk menangani berbagai jenis HTTP request.

Kode contoh routing HTTP GET dan parameter dinamis pada controller NestJS

Langkah 7: Middleware, Pipes, dan Guards

NestJS menyediakan fitur untuk memproses request secara lebih lanjut:

Middleware: Fungsi yang dijalankan sebelum request mencapai controller, misalnya untuk logging atau autentikasi.
Pipes: Untuk validasi dan transformasi data input.
Guards: Untuk mengatur akses dan otorisasi.

Contoh middleware sederhana:

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`Request... ${req.method} ${req.originalUrl}`);
    next();
  }
}

Kode contoh middleware logger yang mencatat method dan URL request di NestJS

Langkah 8: Database dengan TypeORM dan Mongoose

NestJS mendukung integrasi dengan berbagai database melalui ORM dan ODM populer seperti TypeORM untuk SQL dan Mongoose untuk MongoDB.

Contoh konfigurasi TypeORM di app.module.ts :

TypeOrmModule.forRoot({
  type: 'mysql',
  host: 'localhost',
  port: 3306,
  username: 'root',
  password: 'password',
  database: 'test',
  entities: [__dirname + '/**/*.entity{.ts,.js}'],
  synchronize: true,
}),

Contoh schema Mongoose:

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

@Schema()
export class Cat extends Document {
  @Prop()
  name: string;

  @Prop()
  age: number;

  @Prop()
  breed: string;
}

export const CatSchema = SchemaFactory.createForClass(Cat);

Diagram yang menunjukkan integrasi database menggunakan TypeORM dan Mongoose dalam aplikasi NestJS

Langkah 9: Testing dan Debugging Aplikasi NestJS

NestJS mendukung testing unit dan e2e menggunakan Jest. Contoh testing service:

import { Test, TestingModule } from '@nestjs/testing';
import { UsersService } from './users.service';

describe('UsersService', () => {
  let service: UsersService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [UsersService],
    }).compile();

    service = module.get(UsersService);
  });

  it('should return list of users', () => {
    expect(service.getUsers()).toEqual(['User1', 'User2', 'User3']);
  });
});

Untuk debugging, Anda dapat menggunakan debugger bawaan VSCode atau console.log untuk tracing.