Menerapkan Arsitektur Bersih dengan Nest.JS

Artikel ini ditujukan untuk para penggemar yang berusaha keras untuk menulis kode yang bersih, terukur, dan yang lebih penting dapat direfaktorkan. Ini akan memberikan gambaran tentang bagaimana Nest.JS dapat membantu kita menulis kode bersih dan arsitektur dasar apa yang digunakannya.

Menerapkan arsitektur yang bersih dengan Nest.JS akan mengharuskan kita untuk terlebih dahulu memahami apa kerangka kerja ini dan bagaimana cara kerjanya.

Nest atau Nest.JS adalah kerangka kerja untuk membangun aplikasi Node.js yang efisien dan skalabel (sisi server) yang dibuat dengan TypeScript. Ini menggunakan Express atau Fastify dan memungkinkan tingkat abstraksi untuk memungkinkan pengembang menggunakan banyak modul (pihak ketiga) dalam kode mereka.

Mari kita gali lebih dalam tentang apa sebenarnya arsitektur bersih ini. 

Nah, Anda semua mungkin pernah atau setidaknya pernah mendengar tentang arsitektur MVC. MVC adalah singkatan dari Model, View, Controller. Ide di balik ini adalah untuk memisahkan struktur proyek kami menjadi 3 bagian yang berbeda.

1. Model: Ini akan berisi file Object yang memetakan dengan Relasi/Dokumen di DB.

2. Pengendali: Ini adalah penangan permintaan dan bertanggung jawab atas implementasi logika bisnis dan semua manipulasi data.

3. Lihat: Bagian ini akan berisi file-file yang berkaitan dengan tampilan data, baik file HTML atau beberapa file mesin template.

Untuk membuat model, kita memerlukan semacam alat/modul/library ORM/ODM untuk membangunnya. Misalnya, jika Anda langsung menggunakan modul, katakanlah 'sequelize', dan kemudian gunakan yang sama untuk mengimplementasikan login di controller Anda dan membuat logika bisnis inti Anda bergantung pada 'sequelize'. Sekarang, katakanlah setelah 10 tahun, ada alat yang lebih baik di pasar yang ingin Anda gunakan, tetapi segera setelah Anda mengganti sekuelnya, Anda harus mengubah banyak baris kode untuk mencegahnya. pemecahan. Selain itu, Anda harus menguji semua fitur sekali lagi untuk memeriksa apakah fitur tersebut berhasil diterapkan atau tidak yang dapat membuang waktu dan sumber daya yang berharga juga. Untuk mengatasi tantangan ini, kita dapat menggunakan prinsip terakhir SOLID yang merupakan Prinsip Pembalikan Ketergantungan, dan teknik yang disebut injeksi ketergantungan untuk menghindari kekacauan seperti itu.

Masih bingung? Mari saya jelaskan secara rinci.

Jadi, apa yang dikatakan Prinsip Pembalikan Ketergantungan dengan kata-kata sederhana adalah, Anda membuat logika bisnis inti Anda dan kemudian membangun ketergantungan di sekitarnya. Dengan kata lain, bebaskan logika inti dan aturan bisnis Anda dari segala jenis ketergantungan dan modifikasi lapisan luar sedemikian rupa sehingga mereka bergantung pada logika inti Anda alih-alih logika Anda bergantung pada ini. Itulah arsitektur yang bersih. Itu menghilangkan ketergantungan dari logika bisnis inti Anda dan membangun sistem di sekitarnya sedemikian rupa sehingga mereka tampaknya bergantung padanya daripada bergantung pada mereka.

Mari kita coba memahaminya dengan diagram di bawah ini.

Sumber: Kerucut Arsitektur Bersih 

Anda dapat melihat bahwa kami telah membagi arsitektur kami menjadi 4 lapisan:

1. Entitas: Pada intinya, entitas adalah model (aturan Perusahaan) yang mendefinisikan aturan perusahaan Anda dan memberi tahu tentang aplikasi itu. Lapisan ini hampir tidak akan berubah dari waktu ke waktu dan biasanya abstrak dan tidak dapat diakses secara langsung. Misalnya, setiap aplikasi memiliki 'pengguna'. Apa semua bidang yang harus disimpan pengguna, jenisnya, dan hubungannya dengan entitas lain akan terdiri dari Entitas.

2. Gunakan kasus: Ini memberitahu kita bagaimana kita bisa menerapkan aturan perusahaan. Mari kita ambil contoh pengguna lagi. Sekarang kita tahu data apa yang akan dioperasikan, use case memberi tahu kita cara mengoperasikan data ini, seperti pengguna akan memiliki kata sandi yang perlu dienkripsi, pengguna perlu dibuat, dan kata sandi dapat diubah kapan saja. titik waktu tertentu, dll.

3. Pengendali/Gerbang: Ini adalah saluran yang membantu kami mengimplementasikan kasus penggunaan menggunakan alat dan pustaka eksternal menggunakan injeksi ketergantungan.

4. Alat Eksternal: Semua alat dan pustaka yang kami gunakan untuk membangun logika kami akan berada di bawah lapisan ini, mis. ORM, Emailer, Enkripsi, dll.

Alat yang kami gunakan akan bergantung pada bagaimana kami menyalurkannya untuk menggunakan kasus dan pada gilirannya, kasus penggunaan akan bergantung pada entitas yang merupakan inti dari bisnis kami. Dengan cara ini kita telah membalikkan ketergantungan dari luar ke dalam. Itulah yang disiratkan oleh Dependency Inversion Principal dari SOLID.

Oke, sekarang, Anda sudah memahami inti dari Nest.JS dan memahami cara kerja arsitektur bersih. Sekarang muncul pertanyaan, bagaimana keduanya terkait?  

Mari kita coba memahami apa saja 3 blok penyusun Nest.JS dan apa yang dilakukan masing-masing blok tersebut.

1. Modul: Nest.JS terstruktur sedemikian rupa sehingga kita dapat memperlakukan setiap fitur sebagai modul. Misalnya, apa pun yang terkait dengan Pengguna seperti model, pengontrol, DTO, antarmuka, dll., dapat dipisahkan sebagai modul. Modul memiliki pengontrol dan banyak penyedia yang merupakan fungsi yang dapat disuntikkan seperti layanan, orm, emailer, dll.

2. Pengontrol: Pengontrol di Nest.JS adalah antarmuka antara jaringan dan logika Anda. Mereka digunakan untuk menangani permintaan dan mengembalikan respons ke sisi klien aplikasi (misalnya, panggilan ke API).

3. Penyedia (Layanan): Penyedia adalah layanan/fungsi yang dapat disuntikkan yang dapat kami masukkan ke pengontrol dan penyedia lain untuk memberikan fleksibilitas dan fungsionalitas tambahan. Mereka mengabstraksikan segala bentuk kompleksitas dan logika.

Untuk meringkas,

• Kami memiliki pengontrol yang bertindak sebagai antarmuka (lapisan ke-3 arsitektur bersih)
• Kami memiliki penyedia yang dapat disuntikkan untuk menyediakan fungsionalitas (lapisan ke-4 arsitektur bersih: DB, Perangkat, dll.)
• Kami juga dapat membuat layanan dan repositori untuk menentukan kasus penggunaan kami (Lapisan ke-2)
• Kami dapat mendefinisikan entitas kami menggunakan penyedia DB (Lapisan Pertama)

Kesimpulan:

Nest.JS adalah kerangka kerja Node.JS yang kuat dan TypeScript paling terkenal yang tersedia saat ini. Sekarang setelah Anda memahami kerangka kerja ini, Anda pasti bertanya-tanya apakah kami dapat menggunakannya untuk membangun struktur proyek dengan arsitektur yang bersih. Nah, jawabannya adalah -Ya! Sangat. Bagaimana? Akan saya jelaskan di seri artikel berikutnya. 

Sampai saat itu, Tetap disini!

Tentang Penulis:

Junaid Bhat saat ini bekerja sebagai Tech Lead di Mantra Labs. Dia adalah penggemar teknologi yang berusaha untuk menjadi insinyur yang lebih baik setiap hari dengan mengikuti standar industri dan selaras dengan pendekatan yang lebih terstruktur untuk pemecahan masalah. 

Baca blog terbaru kami: Kerangka Golang-Beego dan Aplikasinya

Pengetahuan itu layak disampaikan di kotak masuk Anda