WEB-DEVELOPMENT FRONTEND BROWSER JAVASCRIPT WEB-WORKERS INDEXEDDB WORKFLOW-ENGINE STATE-MANAGEMENT OFFLINE-FIRST PWA RESILIENCE PERFORMANCE-OPTIMIZATION SYSTEM-DESIGN ARCHITECTURE DATA-PERSISTENCE MULTITHREADING USER-EXPERIENCE CLIENT-SIDE-WORKFLOW BACKGROUND-PROCESSING LONG-RUNNING-OPERATIONS WEB-API

Membangun Workflow Engine Sederhana di Browser: Mengelola Tugas Berurutan dan Stateful dengan IndexedDB dan Web Workers

⏱️ 16 menit baca
👨‍💻

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:

Sebuah workflow engine di browser akan membantu kita mengatasi masalah ini dengan:

  1. Mengisolasi tugas berat dari main thread.
  2. Mempersistenkan status workflow agar bisa dilanjutkan kapan saja.
  3. 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:

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:

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:

💡 Contoh Penggunaan IndexedDB untuk Workflow State:

Kita bisa menyimpan objek yang merepresentasikan setiap workflow yang sedang berjalan, termasuk:

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:

❌ Batasan Web Workers:

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.

5.3. Komunikasi Antara Main Thread dan Worker

Komunikasi antara main thread dan Web Worker dilakukan melalui postMessage().

// 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:

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.

🔗 Baca Juga