@vanillaspa/sqlite-database 1.0.0 → 1.1.0

package/index.js

@@ -1,153 +1,97 @@
 import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
-
 // https://www.npmjs.com/package/@sqlite.org/sqlite-wasm
 // https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers
 
-export const name = "sqlite";
+if (!window.Worker) throw new Error(`Your browser doesn't support web workers.`);
+export const name = "sqlite"; // module name
+try {
+    const sqlite3 = await sqlite3InitModule({ print: console.log, printErr: console.error });
+    console.log('SQLite3 version:', sqlite3.version.libVersion);
+} catch (err) {
+    console.error('Initialization error:', err.name, err.message);
+}
 
-const workers = {};
+const workers = new Map();
 
-function initalizeWorker(name) {
-    let worker = new Worker(new URL('./sqliteWorker.js', import.meta.url), { type: 'module' });
-    if (workers[name]) {
-        console.error("InstantiationError: already taken");
-        worker.terminate();
-    } else {
-        workers[name] = worker;
-    }
+function getWorker(name = 'default') {
+    const worker = workers.get(name);
+    if (!worker) throw new Error(`No worker for "${name}"`);
+    return worker;
 }
 
-export function createDB(name = 'default') {
+function initializeWorker(name) {
+    if (workers.has(name)) throw new Error(`Worker "${name}" already exists.`);
+    const worker = new Worker(new URL('./sqliteWorker.js', import.meta.url), { type: 'module' });
+    workers.set(name, worker);
+}
+
+function enqueue(worker, payload) {
+    const { port1, port2 } = new MessageChannel();
+
     return new Promise((resolve, reject) => {
-        initalizeWorker(name);
-        let worker = getWorker(name);
-        worker.onmessage = function ({ data }) {
-            const { type, message } = data;
-            if (type === 'created') {
-                resolve({ message });
-            }
-        }
-        worker.onerror = (error) => {
-            reject(new Error(error));
+        port1.onmessage = ({ data }) => {
+            port1.close();
+            data.type === 'error'
+                ? reject(new Error(data.message))
+                : resolve(data.result);
+        };
+        port1.onmessageerror = () => {
+            port1.close();
+            reject(new Error('MessageChannel deserialization error'));
         };
-        worker.postMessage({ action: 'createDB', name });
-    });
-}
 
-export async function deleteAndTerminateDB(name) {
-    var root = await navigator.storage.getDirectory();
-    let fileSystemFileHandle = await root.getFileHandle(`${name}.sqlite3`);
-    if (fileSystemFileHandle) {
-        let worker = workers[name];
-        worker.onmessage = async function ({ data }) {
-            const { type } = data;
-            if (type === 'closed') {
-                console.log("Removing...", fileSystemFileHandle);
-                await fileSystemFileHandle.remove();
-                await worker.terminate();
-            }
-            delete workers[name];
-        }
-        worker.postMessage({ action: 'closeDB' });
-    }
+        worker.postMessage(payload, [port2]);
+    })
 }
 
+// Public API
 export function downloadDB(name = 'default') {
-    let worker = workers[name];
-    if (worker) {
-        worker.onmessage = function ({ data }) {
-            const { type } = data;
-            if (type === 'application/vnd.sqlite3') {
-                let downloadChannel = new BroadcastChannel("download_channel");
-                downloadChannel.postMessage(data);
-                downloadChannel.close();
-            }
-        }
-        worker.postMessage({ action: 'downloadDB' });
-    }
+    getWorker(name).postMessage({ action: 'downloadDB' });
 }
 
-export function executeQuery(sql, name = 'default') {
-    return new Promise((resolve, reject) => {
-        let worker = getWorker(name);
-        if (worker) {
-            worker.onmessage = function ({ data }) {
-                const { type } = data;
-                if (type === 'application/json') {
-                    const { result } = data;
-                    resolve(result);
-                }
-            }
-            worker.onerror = (error) => {
-                reject(error);
-            };
-            worker.postMessage({ action: "executeQuery", sql });
-        } else {
-            reject(new Error("No worker"));
-        }
-    });
+export function createDB(name = 'default') {
+    initializeWorker(name); // in try-catch?
+    return enqueue(getWorker(name), { action: 'createDB', name });
 }
 
-export function executeStatement({ sql, values, name = "default" }) {
-    return new Promise((resolve, reject) => {
-        let worker = getWorker(name);
-        if (worker) {
-            worker.onmessage = function ({ data }) {
-                const { type } = data;
-                if (type === 'application/json') {
-                    const { result } = data;
-                    resolve(result);
-                }
-            }
-            worker.onerror = (error) => {
-                reject(error);
-            };
-            worker.postMessage({ action: "prepareStatement", sql, values });
-        } else {
-            reject(new Error("No worker"));
-        }
-    });
+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);
 }
 
-export function getWorker(name = 'default') {
-    let worker = workers[name];
-    return worker ? worker : undefined;
+export function executeQuery(sql, name = 'default') {
+    return enqueue(getWorker(name), { action: "executeQuery", sql });
 }
 
-export function getWorkers() {
-    return workers;
+export function executeStatement({ sql, values, name = "default" }) {
+    return enqueue(getWorker(name), { action: "prepareStatement", sql, values });
 }
 
 export function uploadDB(fileName, arrayBuffer) {
-    let [name, extension] = fileName.split(".");
-    if (['sqlite', 'sqlite3'].includes(extension)) {
-        let worker = workers[name];
-        if (!worker) {
-            initalizeWorker(name);
-            worker = getWorker(name);
-            console.log({worker})
-        } // TODO: allow overwrite
-        worker.postMessage({ action: 'uploadDB', name, arrayBuffer });
-    } else {
-        throw new Error({ name: "UnsupportedError", message: "Unsupported extension" });
+    const [name, extension] = fileName.split(".");
+    if (!['sqlite', 'sqlite3'].includes(extension)) {
+        throw new Error(`UnsupportedError: Unsupported extension ".${extension}"`);
     }
+    if (!workers.has(name)) initializeWorker(name);
+    return enqueue(workers.get(name), { action: 'uploadDB', name, arrayBuffer });
 }
 
 export function terminate(name = 'default') {
-    let worker = workers[name];
+    let worker = workers.get(name);
     if (worker) {
-        worker.postMessage({ command: 'terminate' });
-    } 
+        worker.terminate();
+        workers.delete(name);
+    }
 }
 
-if (window.Worker) {
-    try {
-        // instantiation test
-        const sqlite3 = await sqlite3InitModule({ print: console.log, printErr: console.error });
-        console.log('Running SQLite3 version', sqlite3.version.libVersion);
-    } catch (err) {
-        console.error('Initialization error:', err.name, err.message);
-    }
-} else {
-    console.error('Your browser doesn\'t support web workers.');
+export function getWorkers() {
+    return workers;
 }

package/package.json

@@ -28,5 +28,5 @@
         "url": "git+https://github.com/vanillaspa/sqlite-database.git"
     },
     "type": "module",
-    "version": "1.0.0"
+    "version": "1.1.0"
 }

package/sqliteWorker.js

@@ -1,31 +1,65 @@
 import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
 
-var db = null;
-var sqlite3 = null;
+let db = null;
+let sqlite3 = null;
+
+async function getInstance() {
+  if (!sqlite3) {
+    sqlite3 = await sqlite3InitModule({ print: console.log, printErr: console.error });
+  }
+  return sqlite3;
+}
+
+function reply(result) {
+  postMessage({ type: 'application/json', result });
+}
+
+function replyError(message) {
+  postMessage({ type: 'error', message });
+}
+
+function handleSQLiteError(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')) {
+    console.error('Unique constraint violation:', sql, e.message);
+  } else {
+    console.error("Error executing SQL_", sql, e.message);
+  }
+  replyError(e.message);
+}
 
 onmessage = async function ({ data }) {
   const { action } = data;
   switch (action) {
+    case 'downloadDB': { // special case fire-and-forget - no reply(), no enqueue()
+      try {
+        const byteArray = sqlite3.capi.sqlite3_js_db_export(db);
+        const blob = new Blob([byteArray.buffer], { type: "application/vnd.sqlite3" });
+        postMessage({ type: "application/vnd.sqlite3", blob }); // send the database Blob to the API
+      } catch (e) {
+        console.error('downloadDB failed:', e.message)
+      }
+      break;
+    }
     case 'createDB': {
       const { name } = data;
-      const { newDB, message } = await createDatabase(name)
-      db = newDB;
-      postMessage({ type: 'created', message });
+      try {
+        const { newDB, message } = await createDatabase(name)
+        db = newDB;
+        reply(message);
+      } catch (e) {
+        replyError(e.message)
+      }
       break;
     }
     case 'executeQuery': {
       const { sql } = data;
       try {
-        const result = await db.exec({ sql, returnValue: "resultRows" });
-        // console.log(sql, result);
-        postMessage({ result, type: "application/json" });
+        const result = db.exec({ sql, returnValue: "resultRows" });
+        reply(result);
       } catch (e) {
-        if (e.message.indexOf("SQLITE_CANTOPEN") != -1) {
-          console.info("Info: Currently no SQLite database available for this worker. Upload a new database or reload the page.");
-        }
-        if (e.message.indexOf("SQLITE_CONSTRAINT_UNIQUE") != -1) {
-          console.error("Error executing SQL statement", sql, e.message);
-        }
+        handleSQLiteError(sql, e)
       }
       break;
     }
@@ -33,102 +67,72 @@ onmessage = async function ({ data }) {
       const { sql, values } = data;
       let stmt;
       try {
-        // console.debug(sql, values);
-        stmt = await db.prepare(sql, values);
-        const columns = stmt.getColumnNames();
-        // console.debug("columns", columns);
+        stmt = db.prepare(sql);
         stmt.bind(values);
-        // console.debug("stmt", stmt)
+        const columns = stmt.getColumnNames();
         const result = [];
         while (stmt.step()) {
-          let row = stmt.get([]);
-          let zipped = columns.map(function (columnName, index) {
-            return [columnName, row[index]];
-          });
-          let obj = Object.fromEntries(zipped);
-          result.push(obj);
+          const row = stmt.get([]);
+          result.push(Object.fromEntries(columns.map((columnName, index) => [columnName, row[index]])));
         }
-        // console.debug("RESULT", result)
-        postMessage({ result, type: "application/json" });
+        reply(result);
       } catch (e) {
-        if (e.message.indexOf("SQLITE_CANTOPEN") != -1) {
-          console.info("Info: Currently no SQLite database available for this worker. Upload a new database or reload the page.");
-        } else if (e.message.indexOf("SQLITE_CONSTRAINT_UNIQUE") != -1) {
-          console.error("Error executing SQL statement", sql, e.message);
-        } else {
-          console.error("Error executing SQL statement", sql, e.message);
-        }
+        handleSQLiteError(sql, e);
       } finally {
-        stmt.finalize();
+        stmt?.finalize();
       }
       break;
     }
-    case 'uploadDB':
+    case 'uploadDB': {
       const { name, arrayBuffer } = data;
-      const { message } = await uploadDatabase(name, arrayBuffer)
-      console.log(message, db);
-      break;
-    case 'downloadDB':
       try {
-        const byteArray = sqlite3.capi.sqlite3_js_db_export(db);
-        const blob = new Blob([byteArray.buffer], { type: "application/vnd.sqlite3" });
-        postMessage(blob); // send the database Blob to the API
+        const message = await uploadDatabase(name, arrayBuffer)
+        reply(message);
       } catch (e) {
-        if (e.message.indexOf("SQLITE_NOMEM") != -1)
-          postMessage({ type: "application/vnd.sqlite3", error: "SQLITE_NOMEM" });
-        else
-          console.error(e);
+        replyError(e.message);
       }
       break;
-    case 'closeDB':
-      closeDB();
-      postMessage({ type: "closed" });
+    }
+    case 'closeDB': {
+      try {
+        closeDB();
+        reply(null);
+      } catch (e) {
+        replyError(e.message);
+      }
       break;
+    }
     default:
-      console.log(data)
+      console.warn('Unknown action:', data)
   }
 }
 
 async function createDatabase(name) {
-  const sqlite3 = await getInstance();
-  return 'opfs' in sqlite3
-    ? { newDB: new sqlite3.oo1.OpfsDb(`/${name}.sqlite3`), message: `OPFS is available, created persisted database at /${name}.sqlite3` }
-    : { newDB: new sqlite3.oo1.DB(`/${name}.sqlite3`, 'ct'), message: `OPFS is not available, created transient database /${name}.sqlite3` };
+  const instance = await getInstance();
+  return 'opfs' in instance
+    ? {
+      newDB: new instance.oo1.OpfsDb(`/${name}.sqlite3`),
+      message: `OPFS is available, created persisted database at /${name}.sqlite3`
+    }
+    : {
+      newDB: new instance.oo1.DB(`/${name}.sqlite3`, 'ct'),
+      message: `OPFS is not available, created transient database /${name}.sqlite3`
+    };
 }
 
 async function uploadDatabase(name, arrayBuffer) {
-  try {
-    const sqlite3 = await getInstance();
-    if ('opfs' in sqlite3) {
-      const size = await sqlite3.oo1.OpfsDb.importDb(`${name}.sqlite3`, arrayBuffer);
-      if (size) {
-        db = new sqlite3.oo1.OpfsDb(`/${name}.sqlite3`);
-        return { message: `New DB imported as ${name}.sqlite3. (${arrayBuffer.byteLength} Bytes)` }
-      } else {
-        throw new Error({ name: "ImportError", message: "Empty size" })
-      }
-    } else { // TODO allow alternative
-      throw new Error({ name: "OPFSMissingError", message: "Unsupported operation due to missing OPFS support." });
-    }
-  } catch (err) {
-    console.error(err.name, err.message);
-  }
+  const instance = await getInstance();
+  if (!('opfs' in instance)) throw new Error('OPFSMissingError: Unsupported operation due to missing OPFS support.');
+  const size = await instance.oo1.OpfsDb.importDb(`${name}.sqlite3`, arrayBuffer);
+  if (!size) throw new Error('ImportError: Empty size after import.');
+  db = new instance.oo1.OpfsDb(`/${name}.sqlite3`);
+  return `New DB imported as ${name}.sqlite3. (${arrayBuffer.byteLength} Bytes)`;
 }
 
 function closeDB() {
   if (db) {
     console.log("Closing...", db);
     db.close();
-  }
-}
-
-async function getInstance() {
-  try {
-    if (!sqlite3) {
-      sqlite3 = await sqlite3InitModule({ print: console.log, printErr: console.error });
-    }
-    return sqlite3;
-  } catch (err) {
-    console.error(err.name, err.message);
+    db = null;
   }
 }