@vanillaspa/sqlite-database 1.2.7 → 1.4.0

package/index.js

@@ -1,8 +1,10 @@
 import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
-import { dispatchEvent } from '@vanillaspa/event-bus';
+import { addEventListener, dispatchEvent } from '@vanillaspa/event-bus';
 
 if (!window.Worker) throw new Error(`Your browser doesn't support web workers.`);
-export const name = "sqlite"; // module name
+
+export const name = "sqlite";
+
 try {
     const sqlite3 = await sqlite3InitModule({ print: console.log, printErr: console.error });
     console.log('SQLite3 version:', sqlite3.version.libVersion);
@@ -11,11 +13,8 @@ try {
 }
 
 const workers = new Map();
-
-function getWorker(name = 'default') {
-    const worker = workers.get(name);
-    if (!worker) throw new Error(`No worker for "${name}"`);
-    return worker;
+export function getWorkers() {
+    return workers;
 }
 
 function initializeWorker(name) {
@@ -41,63 +40,95 @@ function enqueue(worker, payload) {
     })
 }
 
-// Public API
-export function createDB(name = 'default') {
-    initializeWorker(name);
-    return enqueue(getWorker(name), { action: 'createDB', name });
-}
-
-export async function deleteAndTerminateDB(name) {
-    const worker = getWorker(name);
-    await enqueue(worker, { action: 'closeDB' })
-    const root = await navigator.storage.getDirectory();
-    const fileHandle = await root.getFileHandle(`${name}.sqlite3`).catch(() => null);
-    if (fileHandle) await fileHandle.remove();
-    worker.terminate();
-    workers.delete(name);
+function fire(type, detail, context) {
+    dispatchEvent(new CustomEvent(type, { detail: { ...detail, target: context } }));
 }
+// event-bus listener
+addEventListener('sqlite:createDB', async (event) => {
+    const { name, target } = event.datail;
+    try {
+        initializeWorker(name);
+        const result = await enqueue(workers.get(name), { action: 'createDB', name });
+        fire('sqlite:ready', { result, name }, target);
+    } catch (error) {
+        fire('sqlite:error', { error: error.message, action: 'createDB' }, target);
+    }
+}, import.meta);
 
-export function downloadDB(name = 'default') {
-    enqueue(getWorker(name), { action: 'downloadDB' }).then(blob => {
-        dispatchEvent(new CustomEvent('sqlite:download', { detail: { blob, name } }))
-    })
-}
+addEventListener('sqlite:query', async (event) => {
+    const { sql, name, target } = event.detail;
+    try {
+        const result = await enqueue(workers.get(name), { action: "executeQuery", sql });
+        fire('sqlite:result', { result, sql }, context);
+    } catch (error) {
+        fire('sqlite:error', { error: error.message, action: 'executeQuery', sql }, target);
+    }
+}, import.meta);
 
-export function executeQuery(sql, name = 'default') {
-    return enqueue(getWorker(name), { action: "executeQuery", sql });
-}
+addEventListener('sqlite:statement', async (event) => {
+    const { sql, values, name, target } = event.detail;
+    try {
+        const result = await enqueue(workers.get(name), { action: "prepareStatement", sql, values });
+        fire('sqlite:result', { result, sql }, target);
+    } catch (error) {
+        fire('sqlite:error', { error: error.message, action: 'prepareStatement', sql }, target);
+    }
+}, import.meta)
 
-export function executeStatement({ sql, values, name = "default" }) {
-    return enqueue(getWorker(name), { action: "prepareStatement", sql, values });
-}
+addEventListener('sqlite:upload', async (event) => {
+    const { fileName, arrayBuffer, target } = event.detail;
+    try {
+        const [name, extension] = fileName.split(".");
+        if (!['sqlite', 'sqlite3'].includes(extension)) {
+            throw new Error(`UnsupportedError: Unsupported extension ".${extension}"`);
+        }
+        if (!workers.has(name)) initializeWorker(name);
+        const result = await enqueue(workers.get(name), { action: 'uploadDB', name, arrayBuffer });
+        fire('sqlite:upload', { result, name }, target)
+    } catch (error) {
+        fire('sqlite:error', { error: error.message, action: 'uploadDB' }, target);
+    }
+}, import.meta);
 
-export function uploadDB(fileName, arrayBuffer) {
-    const [name, extension] = fileName.split(".");
-    if (!['sqlite', 'sqlite3'].includes(extension)) {
-        throw new Error(`UnsupportedError: Unsupported extension ".${extension}"`);
+addEventListener('sqlite:download', async (event) => {
+    const { name, target } = event.detail;
+    try {
+        const blob = await enqueue(workers.get(name), { action: 'downloadDB' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = `${name}.sqlite3`;
+        a.click();
+        URL.revokeObjectURL(url)
+        fire('sqlite:downloaded', { name }, target);
+    } catch (error) {
+        fire('sqlite:error', { error: error.message, action: 'downloadDB' }, target);
     }
-    if (!workers.has(name)) initializeWorker(name);
-    return enqueue(workers.get(name), { action: 'uploadDB', name, arrayBuffer });
-}
+}, import.meta);
 
-export function terminate(name = 'default') {
-    const worker = workers.get(name);
-    if (worker) {
-        worker.terminate();
+addEventListener('sqlite:closeDB', async (event) => {
+    const { name, target } = event.detail;
+    try {
+        await enqueue(workers.get(name), { action: 'closeDB' });
+        workers.get(name).terminate();
         workers.delete(name);
+        fire('sqlite:closed', { name }, target);
+    } catch (error) {
+        fire('sqlite:error', { error: error.message, action: 'closeDB' }, target);
     }
-}
+}, import.meta);
 
-export function getWorkers() {
-    return workers;
-}
-
-// addEventListener('sqlite:download', (event) => {
-//     const { blob, name } = event.detail;
-//     const url = URL.createObjectURL(blob);
-//     const a = document.createElement('a');
-//     a.href = url;
-//     a.download = `${name}.sqlite3`;
-//     a.click();
-//     URL.revokeObjectURL(url);
-// });
+addEventListener('sqlite:deleteDB', async (event) => {
+    const { name, target } = event.detail;
+    try {
+        await enqueue(workers.get(name), { action: 'closeDB' });
+        const root = await navigator.storage.getDirectory();
+        const fileHandle = await root.getFileHandle(`${name}.sqlite3`).catch(() => null);
+        if (fileHandle) await fileHandle.remove();
+        workers.get(name).terminate();
+        workers.delete(name);
+        fire('sqlite:deleted', { name }, target);
+    } catch (error) {
+        fire('sqlite:error', { error: error.message, action: 'deleteDB' }, target);
+    }
+}, import.meta);

package/package.json

@@ -10,9 +10,11 @@
     },
     "homepage": "https://github.com/vanillaspa/sqlite-database#readme",
     "keywords": [
+        "BroadcastChannel",
         "Database",
         "EventBus",
         "JavaScript",
+        "MessageChannel",
         "OPFS",
         "SPA",
         "SQLite",
@@ -30,5 +32,5 @@
         "url": "git+https://github.com/vanillaspa/sqlite-database.git"
     },
     "type": "module",
-    "version": "1.2.7"
+    "version": "1.4.0"
 }

package/sqliteWorker.js

@@ -2,7 +2,6 @@ import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
 
 let db = null;
 let sqlite3 = null;
-let port;
 
 async function getInstance() {
   if (!sqlite3) {
@@ -11,17 +10,17 @@ async function getInstance() {
   return sqlite3;
 }
 
-function reply(result) {
+function reply(port, result) {
   port.postMessage({ type: 'application/json', result });
   port.close();
 }
 
-function replyError(message) {
+function replyError(port, message) {
   port.postMessage({ type: 'error', message });
   port.close();
 }
 
-function handleSQLiteError(sql, e) {
+function handleSQLiteError(port, sql, e) {
   if (e.message.includes('SQLITE_CANTOPEN')) {
     console.info("Info: No SQLite database available. Upload a new database or reload the page.");
   } else if (e.message.includes('SQLITE_CONSTRAINT_UNIQUE')) {
@@ -34,15 +33,15 @@ function handleSQLiteError(sql, e) {
 
 onmessage = async function ({ data, ports }) {
   const { action } = data;
-  port = ports[0] ?? null;
+  const port = ports[0] ?? null;
 
   switch (action) {
     case 'closeDB': {
       try {
         closeDB();
-        reply(null);
+        reply(port, null);
       } catch (e) {
-        replyError(e.message);
+        replyError(port, e.message);
       }
       break;
     }
@@ -51,9 +50,9 @@ onmessage = async function ({ data, ports }) {
       try {
         const { newDB, message } = await createDatabase(name)
         db = newDB;
-        reply(message);
+        reply(port, message);
       } catch (e) {
-        replyError(e.message)
+        replyError(port, e.message)
       }
       break;
     }
@@ -61,9 +60,9 @@ onmessage = async function ({ data, ports }) {
       try {
         const byteArray = sqlite3.capi.sqlite3_js_db_export(db);
         const blob = new Blob([byteArray.buffer], { type: "application/vnd.sqlite3" });
-        reply(blob);
+        reply(port, blob);
       } catch (e) {
-        replyError(e.message);
+        replyError(port.e.message);
       }
       break;
     }
@@ -71,9 +70,9 @@ onmessage = async function ({ data, ports }) {
       const { sql } = data;
       try {
         const result = db.exec({ sql: sql.sql, returnValue: "resultRows" });
-        reply(result);
+        reply(port, result);
       } catch (e) {
-        handleSQLiteError(sql, e)
+        handleSQLiteError(port, sql, e)
       }
       break;
     }
@@ -89,9 +88,9 @@ onmessage = async function ({ data, ports }) {
           const row = stmt.get([]);
           result.push(Object.fromEntries(columns.map((columnName, index) => [columnName, row[index]])));
         }
-        reply(result);
+        reply(port, result);
       } catch (e) {
-        handleSQLiteError(sql, e);
+        handleSQLiteError(port, sql, e);
       } finally {
         stmt?.finalize();
       }
@@ -101,9 +100,9 @@ onmessage = async function ({ data, ports }) {
       const { name, arrayBuffer } = data;
       try {
         const message = await uploadDatabase(name, arrayBuffer)
-        reply(message);
+        reply(port, message);
       } catch (e) {
-        replyError(e.message);
+        replyError(port, e.message);
       }
       break;
     }