Mengekstraksi dan memanipulasi data dari elemen <table> HTML yang kompleks langsung di browser sering kali terbentur oleh keterbatasan antarmuka UI web target. Solusi modular untuk masalah ini adalah membangun ekstensi peramban (WebExtension) yang mengurai DOM tabel menjadi struktur relasional, mengompilasi PRQL (Pipelined Relational Query Language) ke SQL, lalu mengeksekusinya menggunakan SQLite berbasis WebAssembly (Wasm) secara in-memory.

Arsitektur Sistem WebExtension

Eksekusi komputasi berat di browser harus memisahkan manipulasi DOM dari proses analitik agar UI thread tidak terblokir. Arsitektur ini terdiri dari dua komponen utama:

  • Content Script: Berjalan pada konteks halaman. Bertanggung jawab mencari elemen <table>, mengekstrak baris dan sel, serta menangani normalisasi dasar.
  • Background Service Worker / Offscreen Document: Mengisolasi runtime prql-js dan engine SQLite Wasm. Karena Manifest V3 Service Worker tidak mendukung eksekusi Wasm di beberapa environment peramban, container offscreen document atau Dedicated Web Worker digunakan sebagai komputasi analitik.

Komunikasi antar komponen memanfaatkan API standar chrome.runtime.sendMessage.

Ekstraksi DOM dan Inferensi Skema

Tantangan utama ekstraksi tabel HTML adalah menangani nested table (tabel bersarang) dan penentuan tipe data kolom secara otomatis.

Ekstraksi Baris Mengabaikan Nested Tables

Gunakan selector direct descendant atau pemfilteran closest() untuk memastikan data dari tabel anak tidak bercampur dengan tabel target.

function extractTableData(tableElement) {
  const headers = Array.from(tableElement.querySelectorAll(':scope > thead > tr > th, :scope > tr > th, :scope > tbody > tr:first-child > th'))
    .map((th, idx) => sanitizeColumnName(th.innerText.trim()) || `col_${idx}`);

  const rows = [];
  const bodyRows = tableElement.querySelectorAll(':scope > tbody > tr, :scope > tr');

  for (const tr of bodyRows) {
    // Lewati baris header jika tr berada di dalam tbody tanpa thead
    if (tr.querySelector('th')) continue;

    const cells = Array.from(tr.querySelectorAll(':scope > td'));
    if (cells.length === 0) continue;

    const rowObj = {};
    cells.forEach((td, idx) => {
      // Fallback: hapus child table jika ada sel dengan nested table
      const clone = td.cloneNode(true);
      const nestedTables = clone.querySelectorAll('table');
      nestedTables.forEach(n => n.remove());

      const colName = headers[idx] || `col_${idx}`;
      rowObj[colName] = clone.innerText.trim();
    });
    rows.push(rowObj);
  }
  return { headers, rows };
}

function sanitizeColumnName(name) {
  return name.toLowerCase().replace(/[^a-z0-9_]/g, '_').replace(/^_+|_+$/g, '');
}

Inferensi Tipe Data dan Sanitasi

Data dari DOM selalu berupa string. Engine in-memory membutuhkan tipe data INTEGER, REAL, atau TEXT untuk operasi agregasi yang valid. Lakukan sampling pada baris untuk menentukan tipe:

function inferAndCast(values) {
  const cleanedValues = values.map(v => v.replace(/^[$,]/g, '').trim());
  const isNumeric = cleanedValues.every(v => v === '' || !isNaN(Number(v)));
  const isInteger = isNumeric && cleanedValues.every(v => v === '' || Number.isInteger(Number(v)));

  if (isInteger) return { type: 'INTEGER', cast: (v) => v === '' ? null : parseInt(v.replace(/,/g, ''), 10) };
  if (isNumeric) return { type: 'REAL', cast: (v) => v === '' ? null : parseFloat(v.replace(/,/g, '')) };
  return { type: 'TEXT', cast: (v) => v };
}

Pipeline Kompilasi: PRQL ke SQL In-Memory

PRQL menyederhanakan penulisan query analitik dibanding SQL tradisional. Pipeline pemrosesan berjalan sebagai berikut:

  1. Memuat dependensi prql-js via ES modules.
  2. Inisialisasi SQLite Wasm (misalnya @sqlite.org/sqlite-wasm).
  3. Pembuatan tabel virtual dan proses batch insert.
  4. Kompilasi input PRQL ke SQL dialect SQLite.
  5. Query SQL dieksekusi dan hasilnya dikembalikan ke antarmuka ekstensi.
import * as prql from 'prql-js';
import { sqlite3Worker1Promiser } from '@sqlite.org/sqlite-wasm';

async function executePipeline(prqlQuery, dataset) {
  // 1. Kompilasi PRQL ke SQLite dialect
  const compileOptions = new prql.CompileOptions();
  compileOptions.target = 'sql.sqlite';
  
  let sql;
  try {
    sql = prql.compile(prqlQuery, compileOptions);
  } catch (err) {
    throw new Error(`Kompilasi PRQL Gagal: ${err}`);
  }

  // 2. Inisialisasi SQLite in-memory DB
  const promiser = await new Promise(resolve => {
    const p = sqlite3Worker1Promiser({
      onready: () => resolve(p)
    });
  });

  await promiser('open', { filename: ':memory:' });

  // 3. Buat skema dan populate data
  const cols = Object.keys(dataset[0]);
  const schemaSql = `CREATE TABLE source_data (${cols.join(', ')});`;
  await promiser('exec', { sql: schemaSql });

  for (const row of dataset) {
    const values = cols.map(c => typeof row[c] === 'string' ? `'${row[c].replace(/'/g, "''")}'` : (row[c] ?? 'NULL'));
    await promiser('exec', { sql: `INSERT INTO source_data VALUES (${values.join(',')});` });
  }

  // 4. Eksekusi SQL hasil kompilasi
  const resultRows = [];
  await promiser('exec', {
    sql: sql,
    callback: (msg) => {
      if (msg.row) resultRows.push(msg.row);
    }
  });

  await promiser('close', {});
  return resultRows;
}

Message Passing Antar Konteks

Untuk menghubungkan Content Script dan Background Worker secara asinkron, gunakan skema pesan terstruktur:

// content-script.js
const tableData = extractTableData(document.querySelector('table#data-grid'));

chrome.runtime.sendMessage({
  action: 'RUN_QUERY',
  payload: {
    prql: 'from source_data | filter amount > 100.0 | aggregate [total = sum amount]',
    dataset: tableData.rows
  }
}, (response) => {
  if (response.error) {
    console.error('Query error:', response.error);
    return;
  }
  console.table(response.data);
});
// service-worker.js
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  if (message.action === 'RUN_QUERY') {
    executePipeline(message.payload.prql, message.payload.dataset)
      .then(data => sendResponse({ data }))
      .catch(error => sendResponse({ error: error.message }));
    return true; // Menandakan penanganan respon secara asinkron
  }
});

Mitigasi Batasan & Edge Cases

  • Sanitasi String ke Numerik: Pemformatan angka lokal (misal koma sebagai pemisah desimal 1.250,50 vs standar US 1,250.50) dapat merusak parsing. Tetapkan normalisasi pemisah ribuan berbasis regex sebelum type casting dilakukan.
  • DOM Bersarang Ekstrem: Hindari table.innerText secara global karena akan menggabungkan teks seluruh baris dan kolom sel bersarang secara tidak terprediksi. Selalu isolasi sel target menggunakan kloning node dan hapus elemen <table> turunan terlebih dahulu.
  • Beban Memori Wasm: Dataset tabel web di atas 50.000 baris dapat memicu fragmentasi memori pada instance SQLite in-memory peramban. Buang instance database (close) setelah query selesai untuk mencegah akumulasi kebocoran memori.