Membangun Workflow Engine Sederhana di Browser: Mengelola Tugas Berurutan dan Stateful dengan IndexedDB dan Web Workers
Pernahkah Anda menghadapi situasi di mana aplikasi web Anda perlu melakukan serangkaian tugas yang kompleks dan berurutan, seperti memproses data besar, mengunggah banyak file, atau melakukan sinkronisasi data yang rumit, namun Anda tidak ingin UI aplikasi menjadi freeze atau tidak responsif? Masalah ini sering muncul di aplikasi web modern, terutama Single Page Applications (SPA) atau Progressive Web Apps (PWA) yang semakin canggih.
Memindahkan logika bisnis yang kompleks ke backend memang solusi yang umum. Namun, ada kalanya kita perlu menjalankan proses-proses ini sepenuhnya di sisi klien, misalnya untuk aplikasi offline-first, menghemat biaya server, atau memproses data yang sangat sensitif tanpa perlu dikirim ke server.
Di sinilah ide Workflow Engine di Browser menjadi relevan. Bayangkan sebuah “otak” kecil di dalam browser Anda yang mampu mengelola serangkaian tugas, melacak statusnya, bahkan melanjutkannya kembali jika browser ditutup atau terjadi error. Artikel ini akan membawa Anda menggali bagaimana kita bisa membangun fondasi workflow engine sederhana menggunakan kombinasi kekuatan IndexedDB untuk persistensi data dan Web Workers untuk eksekusi tugas non-blocking.
1. Pendahuluan: Kenapa Kita Butuh Workflow Engine di Browser?
Aplikasi web modern semakin mirip dengan aplikasi desktop, dengan kemampuan untuk menangani data yang lebih besar dan logika bisnis yang lebih kompleks. Namun, browser memiliki batasan, terutama main thread yang bertanggung jawab untuk rendering UI dan menjalankan sebagian besar kode JavaScript. Jika main thread sibuk dengan komputasi berat, UI akan menjadi lambat atau bahkan freeze, menyebabkan pengalaman pengguna yang buruk.
📌 Masalah yang Ingin Kita Pecahkan:
- UI Blocking: Tugas komputasi atau I/O yang berat memblokir main thread, membuat UI tidak responsif.
- Kehilangan Progress: Jika pengguna menutup tab atau browser crash, semua progress tugas yang sedang berjalan akan hilang.
- Kompleksitas Manajemen Tugas: Mengelola urutan, dependensi, dan status berbagai tugas asinkron bisa menjadi sangat rumit.
- Aplikasi Offline-First: Kebutuhan untuk menjalankan proses bisnis bahkan tanpa koneksi internet.
Sebuah workflow engine di browser akan membantu kita mengatasi masalah ini dengan:
- Mengisolasi tugas berat dari main thread.
- Mempersistenkan status workflow agar bisa dilanjutkan kapan saja.
- Mengotomatisasi urutan dan penanganan error tugas.
2. Apa Itu Workflow Engine (Client-Side)?
Secara umum, workflow engine adalah sebuah sistem yang mengelola dan mengotomatisasi serangkaian tugas (disebut workflow atau process) berdasarkan aturan yang telah ditentukan. Dalam konteks client-side, workflow engine adalah implementasi ringan dari konsep ini yang berjalan sepenuhnya di dalam browser pengguna.
🎯 Fungsi Utama Workflow Engine Client-Side:
- Definisi Workflow: Memungkinkan kita mendefinisikan urutan langkah-langkah (tasks) yang harus dijalankan.
- Eksekusi Tugas Non-Blocking: Menjalankan tugas di luar main thread.
- Persistensi State: Menyimpan status workflow (task mana yang sudah selesai, data apa yang dihasilkan) ke penyimpanan lokal.
- Penanganan Error & Retry: Mengelola kegagalan tugas dan mencoba kembali jika memungkinkan.
- Pemulihan: Melanjutkan workflow dari titik terakhir yang diketahui setelah browser ditutup/dibuka kembali.
Ini bukan tentang mengganti workflow engine backend seperti Apache Airflow atau Temporal.io, melainkan melengkapi mereka dengan kemampuan eksekusi dan persistensi di edge (browser pengguna).
3. Tantangan Mengelola Workflow di Browser
Membangun workflow engine di browser memiliki tantangan unik:
- Lingkungan Eksekusi Tunggal (Main Thread): Seperti yang disebutkan, main thread adalah botol leher. Semua komputasi berat harus dipindahkan.
- Keterbatasan Memori dan CPU: Browser adalah lingkungan yang terbatas. Workflow harus dirancang seefisien mungkin.
- Persistensi Data:
localStorageatausessionStoragetidak cocok untuk data kompleks atau volume besar karena sinkron dan memblokir main thread. Kita butuh solusi asinkron dan terstruktur. - Komunikasi Antar Thread: Bagaimana main thread berkomunikasi dengan worker dan sebaliknya?
- Keamanan: Memastikan data sensitif tetap aman di sisi klien.
4. Fondasi Kita: IndexedDB dan Web Workers
Untuk mengatasi tantangan di atas, kita akan memanfaatkan dua API browser yang sangat powerful: IndexedDB dan Web Workers.
4.1. IndexedDB untuk Persistensi State
IndexedDB adalah database NoSQL berbasis objek yang tersedia di browser. Ini adalah pilihan ideal untuk menyimpan state workflow karena:
- Asinkron: Semua operasi bersifat asinkron, tidak akan memblokir main thread.
- Terstruktur: Mampu menyimpan objek JavaScript kompleks, array, dan tipe data lainnya.
- Kapasitas Besar: Batas penyimpanan jauh lebih besar daripada
localStorage(bisa puluhan atau ratusan MB, tergantung browser dan perangkat). - Transaksional: Mendukung transaksi, memastikan integritas data saat menyimpan atau mengambil state workflow.
- Indeks: Memungkinkan pencarian data yang efisien berdasarkan properti tertentu.
💡 Contoh Penggunaan IndexedDB untuk Workflow State:
Kita bisa menyimpan objek yang merepresentasikan setiap workflow yang sedang berjalan, termasuk:
id: ID unik workflow.name: Nama workflow.status:pending,running,paused,completed,failed.currentTaskIndex: Indeks tugas yang sedang dieksekusi.tasks: Array objek tugas, masing-masing denganname,status,result,error.contextData: Data yang dibutuhkan dan dihasilkan oleh workflow.lastUpdated: Timestamp terakhir kali state diperbarui.
4.2. Web Workers untuk Eksekusi Non-Blocking
Web Workers adalah skrip JavaScript yang berjalan di background, terpisah dari main thread. Mereka memiliki thread eksekusi sendiri, sehingga komputasi berat di dalamnya tidak akan memblokir UI.
✅ Manfaat Web Workers untuk Workflow Engine:
- Isolasi: Tugas berat berjalan di lingkungan terpisah.
- Responsivitas UI: Main thread tetap bebas untuk merender UI dan merespons interaksi pengguna.
- Paralelisme: Meskipun JavaScript bersifat single-threaded, Web Workers memungkinkan konkurensi dengan menjalankan beberapa skrip secara bersamaan di thread yang berbeda.
❌ Batasan Web Workers:
- Tidak Bisa Mengakses DOM: Web Workers tidak memiliki akses langsung ke DOM atau
windowobject. Semua interaksi UI harus melaluipostMessageke main thread. - Komunikasi Melalui Pesan: Semua data antara main thread dan worker harus dikirim sebagai pesan (
postMessage).
5. Merancang Workflow Engine Sederhana Kita
Mari kita rancang struktur dasar workflow engine client-side kita.
5.1. Definisi Workflow dan Task
Pertama, kita butuh cara untuk mendefinisikan workflow. Sebuah workflow adalah urutan tugas. Setiap tugas harus memiliki identitas dan logika eksekusinya.
// main.js atau di mana Anda mendefinisikan workflow
const myComplexWorkflowDefinition = {
id: "upload-and-process-images-123",
name: "Upload dan Proses Gambar",
tasks: [
{
name: "Upload Gambar ke Cloud Storage",
type: "upload", // Tipe tugas untuk worker
payload: { files: [...] } // Data yang dibutuhkan tugas
},
{
name: "Kompresi Gambar",
type: "compress",
payload: { quality: 80 }
},
{
name: "Update Database Lokal",
type: "indexeddb-update",
payload: { imageUrls: [] }
}
]
};
// Objek state workflow yang akan disimpan di IndexedDB
let workflowState = {
id: myComplexWorkflowDefinition.id,
name: myComplexWorkflowDefinition.name,
status: "pending", // pending, running, paused, completed, failed
currentTaskIndex: 0,
tasks: myComplexWorkflowDefinition.tasks.map(task => ({
...task,
status: "pending", // pending, running, completed, failed
result: null,
error: null
})),
contextData: {}, // Data yang dibagikan antar tugas
lastUpdated: Date.now()
};
5.2. State Management Workflow
IndexedDB akan menjadi sumber kebenaran (source of truth) untuk state workflow.
- Inisialisasi: Saat aplikasi dimuat, kita akan memeriksa IndexedDB apakah ada workflow yang
runningataupaused. Jika ada, kita bisa melanjutkan eksekusinya. - Pembaruan Atomik: Setiap kali status tugas berubah atau data konteks diperbarui, kita harus menyimpan seluruh objek
workflowStateke IndexedDB dalam sebuah transaksi. Ini memastikan integritas data. - Query Status: Main thread bisa meng-query IndexedDB untuk menampilkan progress workflow kepada pengguna.
5.3. Komunikasi Antara Main Thread dan Worker
Komunikasi antara main thread dan Web Worker dilakukan melalui postMessage().
- Main Thread ke Worker: Mengirim definisi workflow, task yang harus dijalankan, dan data konteks.
- Worker ke Main Thread: Mengirim pembaruan status (task selesai, error, dll.) dan data hasil.
// main.js
const workflowWorker = new Worker('workflow-worker.js');
workflowWorker.onmessage = async (event) => {
const { type, payload } = event.data;
switch (type) {
case 'workflow-status-update':
// Perbarui workflowState di IndexedDB dan UI
workflowState = { ...workflowState, ...payload.workflowState };
await saveWorkflowState(workflowState); // Fungsi untuk menyimpan ke IndexedDB
updateUI(workflowState); // Fungsi untuk memperbarui UI
break;
case 'workflow-completed':
console.log('Workflow completed!', payload.workflowState);
workflowState = { ...workflowState, ...payload.workflowState };
await saveWorkflowState(workflowState);
updateUI(workflowState);
// Hapus workflow dari IndexedDB jika tidak perlu dipertahankan
break;
case 'workflow-failed':
console.error('Workflow failed!', payload.workflowState);
workflowState = { ...workflowState, ...payload.workflowState };
await saveWorkflowState(workflowState);
updateUI(workflowState);
break;
}
};
// Memulai workflow dari main thread
function startWorkflow(workflowState) {
workflowWorker.postMessage({ type: 'start-workflow', workflowState });
}
6. Contoh Implementasi Praktis (Konsep)
Mari kita lihat struktur kode konseptualnya.
6.1. workflow-worker.js (Logika Eksekusi)
Worker ini akan menerima instruksi dari main thread, menjalankan tugas, dan melaporkan kembali status.
// workflow-worker.js
import { openDB, deleteDB } from 'idb'; // Library idb untuk IndexedDB yang lebih mudah
let db;
const DB_NAME = 'WorkflowDB';
const STORE_NAME = 'workflows';
async function initDB() {
db = await openDB(DB_NAME, 1, {
upgrade(db) {
db.createObjectStore(STORE_NAME, { keyPath: 'id' });
},
});
}
async function getWorkflowState(id) {
return db.get(STORE_NAME, id);
}
async function saveWorkflowState(state) {
return db.put(STORE_NAME, state);
}
// Fungsi dummy untuk menjalankan tugas
async function executeTask(task, contextData) {
console.log(`Executing task: ${task.name} (${task.type})`);
await new Promise(resolve => setTimeout(resolve, 1000)); // Simulasi tugas asinkron
if (task.type === 'upload' && Math.random() < 0.1) { // Simulasi kegagalan
throw new Error('Upload failed!');
}
// Hasil tugas bisa memodifikasi contextData
const result = { message: `${task.name} completed!`, timestamp: Date.now() };
if (task.type === 'upload') {
contextData.imageUrls = [...(contextData.imageUrls || []), `https://cdn.example.com/image-${Math.random().toFixed(4)}.jpg`];
}
return result;
}
self.onmessage = async (event) => {
if (!db) await initDB(); // Pastikan DB terinisialisasi
const { type, workflowState: initialWorkflowState } = event.data;
if (type === 'start-workflow' || type === 'resume-workflow') {
let workflowState = initialWorkflowState;
// Pastikan kita selalu mengambil state terbaru dari DB jika ada
const persistedState = await getWorkflowState(workflowState.id);
if (persistedState && persistedState.status === 'running' || persistedState.status === 'paused') {
workflowState = persistedState;
} else if (persistedState && persistedState.status === 'completed') {
// Jika sudah selesai, jangan mulai lagi
self.postMessage({ type: 'workflow-completed', payload: { workflowState } });
return;
}
workflowState.status = 'running';
self.postMessage({ type: 'workflow-status-update', payload: { workflowState } });
await saveWorkflowState(workflowState);
for (let i = workflowState.currentTaskIndex; i < workflowState.tasks.length; i++) {
let currentTask = workflowState.tasks[i];
if (currentTask.status === 'completed') {
continue; // Lewati tugas yang sudah selesai
}
currentTask.status = 'running';
workflowState.currentTaskIndex = i;
workflowState.lastUpdated = Date.now();
self.postMessage({ type: 'workflow-status-update', payload: { workflowState } });
await saveWorkflowState(workflowState);
try {
const taskResult = await executeTask(currentTask, workflowState.contextData);
currentTask.status = 'completed';
currentTask.result = taskResult;
workflowState.lastUpdated = Date.now();
} catch (error) {
currentTask.status = 'failed';
currentTask.error = error.message;
workflowState.status = 'failed'; // Tandai seluruh workflow gagal
workflowState.lastUpdated = Date.now();
self.postMessage({ type: 'workflow-failed', payload: { workflowState } });
await saveWorkflowState(workflowState);
return; // Hentikan eksekusi workflow
}
}
workflowState.status = 'completed';
workflowState.lastUpdated = Date.now();
self.postMessage({ type: 'workflow-completed', payload: { workflowState } });
await saveWorkflowState(workflowState);
}
};
6.2. main.js (Inisiasi dan UI)
// main.js
import { openDB } from 'idb'; // Library idb untuk IndexedDB yang lebih mudah
const workflowWorker = new Worker('workflow-worker.js');
const DB_NAME = 'WorkflowDB';
const STORE_NAME = 'workflows';
let db;
async function initDB() {
db = await openDB(DB_NAME, 1, {
upgrade(db) {
db.createObjectStore(STORE_NAME, { keyPath: 'id' });
},
});
}
async function saveWorkflowState(state) {
return db.put(STORE_NAME, state);
}
async function getWorkflowState(id) {
return db.get(STORE_NAME, id);
}
function updateUI(state) {
const statusEl = document.getElementById('workflow-status');
const tasksEl = document.getElementById('workflow-tasks');
const contextEl = document.getElementById('workflow-context');
if (!state) {
statusEl.innerHTML = 'Tidak ada workflow aktif.';
tasksEl.innerHTML = '';
contextEl.innerHTML = '';
return;
}
statusEl.innerHTML = `Status Workflow '${state.name}': <strong>${state.status.toUpperCase()}</strong>`;
tasksEl.innerHTML = state.tasks.map(task => `
<li>
${task.name} - Status: <strong style="color: ${task.status === 'completed' ? 'green' : task.status === 'failed' ? 'red' : 'orange'}">${task.status.toUpperCase()}</strong>
${task.error ? `<br><span style="color: red;">Error: ${task.error}</span>` : ''}
${task.result ? `<br><span>Result: ${JSON.stringify(task.result.message)}</span>` : ''}
</li>
`).join('');
contextEl.innerHTML = `Context Data: ${JSON.stringify(state.contextData, null, 2)}`;
}
workflowWorker.onmessage = async (event) => {
const { type, payload } = event.data;
let currentWorkflowState;
if (payload && payload.workflowState) {
currentWorkflowState = payload.workflowState;
await saveWorkflowState(currentWorkflowState); // Pastikan main thread juga menyimpan
updateUI(currentWorkflowState);
}
if (type === 'workflow-completed') {
alert(`Workflow '${currentWorkflowState.name}' Selesai!`);
// Opsional: hapus workflow dari IndexedDB jika sudah selesai
// await db.delete(STORE_NAME, currentWorkflowState.id);
} else if (type === 'workflow-failed') {
alert(`Workflow '${currentWorkflowState.name}' Gagal: ${currentWorkflowState.tasks[currentWorkflowState.currentTaskIndex].error}`);
}
};
document.getElementById('start-workflow-btn').addEventListener('click', async () => {
const workflowDefinition = {
id: "image-pipeline-workflow-456",
name: "Pipeline Gambar Produk",
tasks: [
{ name: "Ambil Gambar dari Kamera", type: "fetch-image", payload: { source: "camera" } },
{ name: "Unggah Gambar ke Server", type: "upload" },
{ name: "Kirim Notifikasi Admin", type: "notify-admin" }
]
};
let workflowState = await getWorkflowState(workflowDefinition.id);
if (!workflowState) {
workflowState = {
id: workflowDefinition.id,
name: workflowDefinition.name,
status: "pending",
currentTaskIndex: 0,
tasks: workflowDefinition.tasks.map(task => ({
...task,
status: "pending",
result: null,
error: null
})),
contextData: { userName: "Budi" },
lastUpdated: Date.now()
};
}
// Jika sudah completed, reset untuk demo
if (workflowState.status === 'completed' || workflowState.status === 'failed') {
workflowState.status = 'pending';
workflowState.currentTaskIndex = 0;
workflowState.tasks = workflowDefinition.tasks.map(task => ({
...task,
status: "pending",
result: null,
error: null
}));
workflowState.contextData = { userName: "Budi" };
}
await saveWorkflowState(workflowState);
updateUI(workflowState);
workflowWorker.postMessage({ type: 'start-workflow', workflowState });
});
// Inisialisasi dan cek workflow yang tertunda saat load
document.addEventListener('DOMContentLoaded', async () => {
await initDB();
const allWorkflows = await db.getAll(STORE_NAME);
const pendingOrRunning = allWorkflows.find(wf => wf.status === 'running' || wf.status === 'paused');
if (pendingOrRunning) {
updateUI(pendingOrRunning);
// Lanjutkan workflow yang tertunda
workflowWorker.postMessage({ type: 'resume-workflow', workflowState: pendingOrRunning });
alert(`Melanjutkan workflow '${pendingOrRunning.name}' yang sebelumnya tertunda.`);
} else {
updateUI(null);
}
});
Dan sedikit HTML untuk UI sederhana:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Client-Side Workflow Engine</title>
</head>
<body>
<h1>Client-Side Workflow Engine Demo</h1>
<button id="start-workflow-btn">Mulai Workflow Baru</button>
<hr>
<div id="workflow-info">
<p id="workflow-status"></p>
<h2>Tugas:</h2>
<ul id="workflow-tasks"></ul>
<h2>Data Konteks:</h2>
<pre id="workflow-context"></pre>
</div>
<script type="module" src="main.js"></script>
</body>
</html>
⚠️ Penting untuk Diperhatikan:
- Error Handling dan Retry: Implementasi di atas masih sangat sederhana. Dalam kasus nyata, Anda perlu mekanisme retry dengan exponential backoff dan penanganan error yang lebih canggih.
- Komunikasi Kompleks: Untuk komunikasi yang lebih kompleks (misalnya, mengirim Transferable Objects atau MessageChannel), Anda bisa mendalami API Web Workers lebih lanjut.
- Idle Detection: Untuk PWA, Anda bisa menggunakan
requestIdleCallbackatauscheduler.postTaskdi main thread untuk menjadwalkan tugas yang tidak kritikal, atau bahkanPeriodic Background Syncuntuk memulai worker secara berkala di background.
Kesimpulan
Membangun workflow engine sederhana di browser dengan IndexedDB dan Web Workers adalah strategi yang sangat efektif untuk mengelola tugas-tugas berat dan berurutan di sisi klien. Ini memungkinkan aplikasi web Anda untuk tetap responsif, tangguh terhadap kegagalan, dan bahkan berfungsi secara offline-first.
Dengan fondasi ini, Anda bisa mengembangkan aplikasi web yang lebih canggih, seperti editor offline, alat sinkronisasi data yang kuat, atau bahkan game berbasis browser yang menyimpan progress secara lokal dan memproses logika kompleks di background. Ingat, kuncinya adalah memindahkan beban kerja dari main thread dan memastikan persistensi state. Dengan begitu, pengalaman pengguna akan tetap mulus, bahkan untuk operasi yang paling menantang sekalipun.