Cara Menggunakan TypeScript dengan Arsitektur Layanan Mikro

Kemampuan mengetik dan modularitas TypeScript yang kuat menjadikannya pilihan yang sangat baik untuk membangun layanan mikro. Dalam arsitektur layanan mikro, setiap layanan merupakan komponen kecil yang dapat disebarkan secara independen yang berkomunikasi dengan layanan lain melalui API. Penggunaan TypeScript dalam konteks ini dapat meningkatkan kualitas kode, meningkatkan kemudahan pemeliharaan, dan memfasilitasi kolaborasi yang lebih baik antar tim.

1. Menyiapkan Proyek TypeScript untuk Layanan Mikro

Untuk mulai menggunakan TypeScript dalam arsitektur layanan mikro, Anda perlu menyiapkan TypeScript untuk setiap layanan mikro. Berikut panduan langkah demi langkah untuk membantu Anda memulai:

1.1 Menginisialisasi Proyek TypeScript

Pertama, inisialisasi proyek Node.js baru dan instal TypeScript:

mkdir my-microservice
cd my-microservice
npm init -y
npm install typescript --save-dev
npx tsc --init

Perintah tsc --init menghasilkan file tsconfig.json dengan konfigurasi TypeScript default. Anda dapat menyesuaikan file ini sesuai dengan kebutuhan Anda.

1.2 Mengonfigurasi tsconfig.json

Perbarui tsconfig.json agar sesuai dengan lingkungan layanan mikro. Berikut contoh konfigurasinya:

{
  "compilerOptions": {
    "target": "ES6",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}

Konfigurasi ini menentukan direktori keluaran dan root, memungkinkan pemeriksaan tipe yang ketat, dan mendukung interoperabilitas modul ES.

2. Menyusun Layanan Mikro dengan TypeScript

Setiap layanan mikro harus memiliki struktur yang terdefinisi dengan baik. Proyek layanan mikro TypeScript yang umum mungkin mencakup:

• src/ - Direktori kode sumber
• src/routes/ - Penangan rute API
• src/services/ - Logika bisnis
• src/models/ - Model dan tipe data
• src/utils/ - Fungsi utilitas
• dist/ - File JavaScript yang dikompilasi
• tests/ - Pengujian unit dan integrasi

2.1 Contoh Struktur Proyek

Berikut contoh sederhana tentang bagaimana Anda dapat menyusun layanan mikro TypeScript:

my-microservice/
├── src/
│   ├── routes/
│   │   └── userRoutes.ts
│   ├── services/
│   │   └── userService.ts
│   ├── models/
│   │   └── userModel.ts
│   ├── utils/
│   │   └── logger.ts
│   └── index.ts
├── dist/
├── tests/
│   └── userService.test.ts
├── package.json
├── tsconfig.json
└── README.md

3. Menulis Kode TypeScript untuk Layanan Mikro

Saat menulis kode TypeScript untuk layanan mikro, Anda harus fokus pada pendefinisian antarmuka dan tipe yang jelas untuk layanan Anda. Ini membantu memastikan bahwa setiap layanan dapat berinteraksi dengan layanan lain secara andal dan dapat diprediksi.

3.1 Mendefinisikan Model dan Jenis

Mulailah dengan mendefinisikan model dan tipe data Anda. Misalnya, model pengguna mungkin terlihat seperti ini:

export interface User {
  id: string;
  name: string;
  email: string;
}

3.2 Menerapkan Layanan

Selanjutnya, terapkan logika bisnis dalam kelas layanan. Berikut contoh layanan untuk mengelola pengguna:

import { User } from '../models/userModel';

export class UserService {
  private users: User[] = [];

  addUser(user: User): void {
    this.users.push(user);
  }

  getUser(id: string): User | undefined {
    return this.users.find(user => user.id === id);
  }
}

3.3 Menyiapkan Rute API

Tentukan rute API untuk menangani permintaan masuk. Berikut contoh dasar penggunaan Express:

import express from 'express';
import { UserService } from './services/userService';
import { User } from './models/userModel';

const app = express();
const userService = new UserService();

app.use(express.json());

app.post('/users', (req, res) => {
  const user: User = req.body;
  userService.addUser(user);
  res.status(201).send(user);
});

app.get('/users/:id', (req, res) => {
  const user = userService.getUser(req.params.id);
  if (user) {
    res.status(200).send(user);
  } else {
    res.status(404).send({ message: 'User not found' });
  }
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

4. Menguji Layanan Mikro

Pengujian sangat penting untuk memastikan keandalan layanan mikro Anda. Gunakan kerangka pengujian seperti jest atau mocha untuk menulis pengujian unit dan integrasi untuk layanan Anda.

4.1 Menulis Tes Unit

Berikut contoh pengujian unit sederhana untuk UserService menggunakan jest:

import { UserService } from '../src/services/userService';
import { User } from '../src/models/userModel';

test('should add and retrieve a user', () => {
  const userService = new UserService();
  const user: User = { id: '1', name: 'Alice', email: 'alice@example.com' };
  userService.addUser(user);
  expect(userService.getUser('1')).toEqual(user);
});

Kesimpulan

Menggunakan TypeScript dengan arsitektur layanan mikro memungkinkan Anda memanfaatkan pengetikan dan modularitas yang kuat, menjadikan layanan Anda lebih tangguh dan mudah dipelihara. Dengan mengikuti praktik terbaik untuk konfigurasi TypeScript, organisasi kode, dan pengujian, Anda dapat membangun layanan mikro yang dapat diskalakan dan andal yang berinteraksi dengan lancar.