@vanillaspa/sqlite-database 1.0.0

package/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

package/README.md

@@ -0,0 +1,20 @@
+## Getting started
+
+To install the sqlite-database into your project, simply run
+
+```bash
+npm install @vanillaspa/sqlite-database
+```
+
+## How-To
+
+Now integrate the sqlite datebase into your app: 
+
+```javascript
+<script type="module">
+  import * as sqlite from '@vanillaspa/sqlite-database';
+  window.sqlite = sqlite;
+</script>
+```
+
+This is only a recommendation. You can use it however you like. With the `sqlite` object attached to the `window` object, you have access to the sqlite-database in your WebComponents.

package/index.js

@@ -0,0 +1,153 @@
+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";
+
+const workers = {};
+
+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;
+    }
+}
+
+export function createDB(name = 'default') {
+    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));
+        };
+        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' });
+    }
+}
+
+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' });
+    }
+}
+
+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 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 function getWorker(name = 'default') {
+    let worker = workers[name];
+    return worker ? worker : undefined;
+}
+
+export function getWorkers() {
+    return workers;
+}
+
+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" });
+    }
+}
+
+export function terminate(name = 'default') {
+    let worker = workers[name];
+    if (worker) {
+        worker.postMessage({ command: 'terminate' });
+    } 
+}
+
+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.');
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+    "author": "Robert Meissner <rome@live.com>",
+    "bugs": {
+        "url": "https://github.com/vanillaspa/sqlite-database/issues"
+    },
+    "description": "A serverless SQLite database inside your browser.",
+    "dependencies": {
+        "@sqlite.org/sqlite-wasm":"^3.51.2-build6"
+    },
+    "homepage": "https://github.com/vanillaspa/sqlite-database#readme",
+    "keywords": [
+        "Database",
+        "JavaScript",
+        "OPFS",
+        "SPA",
+        "SQLite",
+        "Vanilla",
+        "WebAssembly"
+    ],
+    "license": "Unlicense",
+    "main": "index.js",
+    "name": "@vanillaspa/sqlite-database",
+    "publishConfig": {
+        "access": "public"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/vanillaspa/sqlite-database.git"
+    },
+    "type": "module",
+    "version": "1.0.0"
+}

package/sqliteWorker.js

@@ -0,0 +1,134 @@
+import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
+
+var db = null;
+var sqlite3 = null;
+
+onmessage = async function ({ data }) {
+  const { action } = data;
+  switch (action) {
+    case 'createDB': {
+      const { name } = data;
+      const { newDB, message } = await createDatabase(name)
+      db = newDB;
+      postMessage({ type: 'created', 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" });
+      } 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);
+        }
+      }
+      break;
+    }
+    case 'prepareStatement': {
+      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.bind(values);
+        // console.debug("stmt", stmt)
+        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);
+        }
+        // console.debug("RESULT", result)
+        postMessage({ result, type: "application/json" });
+      } 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);
+        }
+      } finally {
+        stmt.finalize();
+      }
+      break;
+    }
+    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
+      } catch (e) {
+        if (e.message.indexOf("SQLITE_NOMEM") != -1)
+          postMessage({ type: "application/vnd.sqlite3", error: "SQLITE_NOMEM" });
+        else
+          console.error(e);
+      }
+      break;
+    case 'closeDB':
+      closeDB();
+      postMessage({ type: "closed" });
+      break;
+    default:
+      console.log(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` };
+}
+
+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);
+  }
+}
+
+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);
+  }
+}