Chain of Responsibility: Clean Code buat Logic Bisnis yang Kacau

Chain of Responsibility: Clean Code buat Logic Bisnis yang Kacau

Gue ceritain soal fungsi yang nge-hantuin mimpi gue.

Setiap sistem, pada akhirnya, pasti punya fungsi yang takut disentuh siapa pun. Awalnya kecil: validasi sederhana, `if` di sini, `if` di sana. Trus requirement numpuk, stakeholder minta "cuma satu pengecualian kecil," dan tiba-tiba kamu ngadepin monster 500-baris yang kayak ditulis komite (karena iya, memang ditulis komite).

Nah, di sinilah **Chain of Responsibility** (CoR) masuk—bukan pake sihir, tapi disiplin. Gue jelasin gimana pattern desain classic ini bisa nge-untangle logic bisnis paling kacau punya kamu.

---

Apa Itu Chain of Responsibility?

Intinya simpel: **meneruskan request lewat rangkaian handler sampai ada yang handle**. Bayangin antrian eskalasi customer service—setiap orang coba solve masalah kamu, kalo nggak bisa, diterusin ke orang berikutnya.

Di kode, alih-alih satu method raksasa yang handle semua skenario, kamu bikin serangkaian handler kecil dan fokus. Setiap handler: proses request **atau** passing ke handler berikutnya.

---

Real-World Scenarios: Kapan CoR Bener-Bener Berguna

1. E-commerce Order Processing

Bayangin: kamu bangun platform e-commerce, `processOrder()` harus handle kode diskon, poin loyalitas, promo musiman, akun korporat, status VIP, partnership khusus. Fungsi itu meledak jadi ratusan baris dengan nested conditional.

Pake CoR, kamu bikin processor individual:

```javascript
class DiscountCodeHandler {
handle(order) {
// Logic diskon di sini
return next ? next.handle(order) : order;
}
}

class LoyaltyPointsHandler {
handle(order) {
// Logic poin loyalitas
return next ? next.handle(order) : order;
}
}
```

Setiap handler urus **satu hal**. Testing dan maintenance jadi gampang banget.

---

2. Content Moderation Pipeline

Platform sosial media punya workflow moderasi kompleks. Posting mungkin harus dicek guideline komunitas, discan ucap kebencian, diflag konten politik, direview pelanggaran hak cipta, dinilai misinformation—sebelum publish.

Biarin semuanya di satu fungsi moderasi? Nggak. Bangun pipeline:

1. **Spam Detection Handler** – Filter spam jelas
2. **Hate Speech Handler** – Flag bahasa abusif
3. **Copyright Handler** – Cek material berhak cipta
4. **Political Content Handler** – Route postingan politik sensitif
5. **Final Review Handler** – Review manual moderator

Tiap step: handle dengan benar **atau** passing ke bawah.

---

3. Payment Authorization Flow

Proses pembayaran butuh layer validasi dan approval banyak. Alih-alih satu payment processor monolitik, coba chain ini:

1. **Fraud Detection Handler** – Blokir transaksi mencurigakan
2. **Credit Limit Handler** – Pastin dana cukup
3. **Bank Verification Handler** – Konfirmi validitas akun
4. **Currency Conversion Handler** – Handle pembayaran internasional
5. **Payment Gateway Handler** – Proses transaksi aktual

Gampang nambah step verifikasi baru tanpa sentuh kode existing.

---

Implementasi Pertama Kamu (JavaScript)

```javascript
// Base handler class
class BaseHandler {
constructor() {
this.nextHandler = null;
}

setNext(handler) {
this.nextHandler = handler;
return handler; // biar bisa chaining
}

handle(request) {
if (this.nextHandler) {
return this.nextHandler.handle(request);
}
return null; // nggak ada handler yang proses
}
}

// Concrete handlers
class AuthenticationHandler extends BaseHandler {
handle(request) {
if (!request.user) {
return { error: 'Authentication required' };
}
console.log('Authentication passed');
return super.handle(request);
}
}

class AuthorizationHandler extends BaseHandler {
handle(request) {
if (request.user.role !== 'admin') {
return { error: 'Insufficient permissions' };
}
console.log('Authorization passed');
return super.handle(request);
}
}

class ValidationHandler extends BaseHandler {
handle(request) {
if (!request.data || Object.keys(request.data).length === 0) {
return { error: 'Invalid data' };
}
console.log('Validation passed');
return super.handle(request);
}
}

// Usage
const authHandler = new AuthenticationHandler();
const authzHandler = new AuthorizationHandler();
const validationHandler = new ValidationHandler();

authHandler.setNext(authzHandler).setNext(validationHandler);

const result = authHandler.handle({
user: { role: 'admin' },
data: { amount: 100 }
});
```

---

Benefit Yang Beneran Berguna

**Maintainability**: Setiap handler cuma urus satu hal. Rule bisnis berubah? Ubah handler yang relevan aja.

**Testability**: Unit test jadi straightforward—test tiap handler isolasi, nggak perlu mock skenario kompleks.

**Flexibility**: Mau urutan processing diubah? Ganti konfigurasi chain aja. Mau conditional routing? Implementasi logic custom di handler.

**Debugging**: Kalo error, kamu tau pasti handler mana yang gagal—karena tiap handler log keputusannya.

---

Pitfalls Yang Harus Dihindari

Jangan bikin handler terlalu generik **atau** terlalu spesifik. Cari balance: setiap handler mewakili rule bisnis yang meaningful. Dan jangan bikin handler aware posisi mereka di chain—biarkan mereka fokus di tanggung jawab masing-masing, percayakan chain-nya yang kerja.

Ingat: CoR nggak soal nge-replace semua conditional logic. Tapi soal **ngatur workflow kompleks** di mana multiple processing steps distinct harus jalan berurutan.

---

Tools & Framework Yang Sudah Pake CoR

Banyak framework modern yang sudah implementasi variasi pattern ini:

- **Express.js middleware** ([expressjs.com](https://expressjs.com)) pake pendekatan chain-like
- **ASP.NET Core middleware pipeline** prinsip mirip
- **Java Servlet Filters** implement chain processing

Bahkan kalo framework kamu nggak eksplisit pake CoR, paham pattern ini bantu desain middleware dan interceptor architecture yang lebih baik.

---

Kapan **JANGAN** Pake Chain of Responsibility

CoR bukan silver bullet. Hindari kalo:

- Processing steps tightly coupled dan selalu jalan bareng
- Performa kritis dan kamu butuh minimize method call overhead
- Urutan processing nggak penting atau fixed
- Kamu punya kurang dari tiga distinct processing steps

---

Bikin Berjalan Di Codebase Kamu

Siap kenalin CoR ke project? Mulai kecil:

1. Identifikasi satu fungsi kompleks yang semua orang hindar
2. Pecah jadi logical processing steps
3. Bikin handler class terpisah tiap step
4. Sambungin mereka jadi chain
5. Test thorough sebelum expand ke area lain

Investasinya return cepat: debugging time berkurang, code review jadi bersih.

---

FAQ

**Q: Gimana handle error di chain?**
A: Setiap handler harusnya proses request sukses **atau** throw exception yang appropriate. Pertimbangkan implementasi error handler di akhir chain buat tangkep request yang nggak ke-process.

**Q: Bisa nggak handler modify request saat passing through?**
A: Bisa banget! Ini common practice. Setiap handler bisa enrich, validate, atau transform request data buat handler selanjutnya.

**Q: Gimana kalo asynchronous processing?**
A: Implementasi modern sering support async/await. Pastikan tiap handler properly `await` handler berikutnya di chain.

**Q: Bedanya sama Strategy pattern apa?**
A: Strategy milih **satu** algoritma dari banyak, sedangkan CoR **coba multiple handlers berurutan** sampai ada yang handle request.

---

Keindahan Chain of Responsibility ada di kesederhanaannya. Dia nggak solve semua masalah arsitektur, tapi kalo diterapin bener, dia transform spaghetti code yang unmaintainable jadi logic terorganisir, readable, yang *future self* kamu bakal thank you banget.