@livestore/wa-sqlite 1.0.1-dev.0

package/src/types/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "compilerOptions": {
+    "target": "ES2020"
+  },
+  "files": ["index.d.ts"]
+}

package/test/AccessHandlePoolVFS.test.js

@@ -0,0 +1,27 @@
+import { TestContext } from "./TestContext.js";
+import { vfs_xOpen } from "./vfs_xOpen.js";
+import { vfs_xAccess } from "./vfs_xAccess.js";
+import { vfs_xClose } from "./vfs_xClose.js";
+import { vfs_xRead } from "./vfs_xRead.js";
+import { vfs_xWrite } from "./vfs_xWrite.js";
+
+const CONFIG = 'AccessHandlePoolVFS';
+const BUILDS = ['default', 'asyncify', 'jspi'];
+
+const supportsJSPI = await TestContext.supportsJSPI();
+
+describe(CONFIG, function() {
+  for (const build of BUILDS) {
+    if (build === 'jspi' && !supportsJSPI) return;
+
+    describe(build, function() {
+      const context = new TestContext({ build, config: CONFIG });
+    
+      vfs_xAccess(context);
+      vfs_xOpen(context);
+      vfs_xClose(context);
+      vfs_xRead(context);
+      vfs_xWrite(context);
+    });
+  }
+});

package/test/IDBBatchAtomicVFS.test.js

@@ -0,0 +1,97 @@
+import { TestContext } from "./TestContext.js";
+import { vfs_xOpen } from "./vfs_xOpen.js";
+import { vfs_xAccess } from "./vfs_xAccess.js";
+import { vfs_xClose } from "./vfs_xClose.js";
+import { vfs_xRead } from "./vfs_xRead.js";
+import { vfs_xWrite } from "./vfs_xWrite.js";
+
+import SQLiteESMFactory from '../dist/wa-sqlite-async.mjs';
+import * as SQLite from '../src/sqlite-api.js';
+import { IDBBatchAtomicVFS } from "../src/examples/IDBBatchAtomicVFS.js";
+
+const CONFIG = 'IDBBatchAtomicVFS';
+const BUILDS = ['asyncify', 'jspi'];
+
+const supportsJSPI = await TestContext.supportsJSPI();
+
+describe(CONFIG, function() {
+  for (const build of BUILDS) {
+    if (build === 'jspi' && !supportsJSPI) return;
+
+    describe(build, function() {
+      const context = new TestContext({ build, config: CONFIG });
+    
+      vfs_xAccess(context);
+      vfs_xOpen(context);
+      vfs_xClose(context);
+      vfs_xRead(context);
+      vfs_xWrite(context);
+    });
+  }
+
+  it('should upgrade v5', async function() {
+    await idbX(indexedDB.deleteDatabase('test'));
+
+    {
+      // Load IndexedDB with v5 data.
+      const db = await new Promise((resolve, reject) => {
+        const request = indexedDB.open('test', 5);
+        request.onupgradeneeded = () => {
+          const db = request.result;
+          db.createObjectStore('blocks', {
+            keyPath: ['path', 'offset', 'version']
+          }).createIndex('version', ['path', 'version']);
+        };
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+      });
+
+      const data = await fetch(new URL('./data/idbv5.json', import.meta.url))
+        .then(response => response.json());
+      const blocks = db.transaction('blocks', 'readwrite').objectStore('blocks');
+      await Promise.all(data.blocks.map(block => {
+        block.data = new Uint8Array(block.data);
+        return idbX(blocks.put(block));
+      }));
+      db.close();
+    }
+
+    // Initialize SQLite.
+    const module = await SQLiteESMFactory();
+    const sqlite3 = SQLite.Factory(module);
+
+    const vfs = await IDBBatchAtomicVFS.create('test', module);
+    // @ts-ignore
+    sqlite3.vfs_register(vfs, true);
+
+    const db = await sqlite3.open_v2('demo');
+
+    let integrity = '';
+    await sqlite3.exec(db, 'PRAGMA integrity_check', (row, columns) => {
+      integrity = /** @type {string} */(row[0]);
+    });
+    expect(integrity).toBe('ok');
+
+    const rows = [];
+    await sqlite3.exec(db, 'SELECT x FROM foo ORDER BY rowid LIMIT 3', (row, columns) => {
+      rows.push(row[0]);
+    });
+    expect(rows).toEqual([1, 2, 3]);
+
+    await sqlite3.close(db);
+    await vfs.close();
+
+    await idbX(indexedDB.deleteDatabase('test'));
+  });
+});
+
+/**
+ * @param {IDBRequest} request 
+ * @returns {Promise}
+ */
+function idbX(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}

package/test/IDBMirrorVFS.test.js

@@ -0,0 +1,27 @@
+import { TestContext } from "./TestContext.js";
+import { vfs_xOpen } from "./vfs_xOpen.js";
+import { vfs_xAccess } from "./vfs_xAccess.js";
+import { vfs_xClose } from "./vfs_xClose.js";
+import { vfs_xRead } from "./vfs_xRead.js";
+import { vfs_xWrite } from "./vfs_xWrite.js";
+
+const CONFIG = 'IDBMirrorVFS';
+const BUILDS = ['asyncify', 'jspi'];
+
+const supportsJSPI = await TestContext.supportsJSPI();
+
+describe(CONFIG, function() {
+  for (const build of BUILDS) {
+    if (build === 'jspi' && !supportsJSPI) return;
+
+    describe(build, function() {
+      const context = new TestContext({ build, config: CONFIG });
+    
+      vfs_xAccess(context);
+      vfs_xOpen(context);
+      vfs_xClose(context);
+      vfs_xRead(context);
+      vfs_xWrite(context);
+    });
+  }
+});

package/test/MemoryAsyncVFS.test.js

@@ -0,0 +1,27 @@
+import { TestContext } from "./TestContext.js";
+import { vfs_xOpen } from "./vfs_xOpen.js";
+import { vfs_xAccess } from "./vfs_xAccess.js";
+import { vfs_xClose } from "./vfs_xClose.js";
+import { vfs_xRead } from "./vfs_xRead.js";
+import { vfs_xWrite } from "./vfs_xWrite.js";
+
+const CONFIG = 'MemoryAsyncVFS';
+const BUILDS = ['asyncify', 'jspi'];
+
+const supportsJSPI = await TestContext.supportsJSPI();
+
+describe(CONFIG, function() {
+  for (const build of BUILDS) {
+    if (build === 'jspi' && !supportsJSPI) return;
+
+    describe(build, function() {
+      const context = new TestContext({ build, config: CONFIG });
+    
+      vfs_xAccess(context);
+      vfs_xOpen(context);
+      vfs_xClose(context);
+      vfs_xRead(context);
+      vfs_xWrite(context);
+    });
+  }
+});

package/test/MemoryVFS.test.js

@@ -0,0 +1,27 @@
+import { TestContext } from "./TestContext.js";
+import { vfs_xOpen } from "./vfs_xOpen.js";
+import { vfs_xAccess } from "./vfs_xAccess.js";
+import { vfs_xClose } from "./vfs_xClose.js";
+import { vfs_xRead } from "./vfs_xRead.js";
+import { vfs_xWrite } from "./vfs_xWrite.js";
+
+const CONFIG = 'MemoryVFS';
+const BUILDS = ['default', 'asyncify', 'jspi'];
+
+const supportsJSPI = await TestContext.supportsJSPI();
+
+describe(CONFIG, function() {
+  for (const build of BUILDS) {
+    if (build === 'jspi' && !supportsJSPI) return;
+
+    describe(build, function() {
+      const context = new TestContext({ build, config: CONFIG });
+    
+      vfs_xAccess(context);
+      vfs_xOpen(context);
+      vfs_xClose(context);
+      vfs_xRead(context);
+      vfs_xWrite(context);
+    });
+  }
+});

package/test/OPFSAdaptiveVFS.test.js

@@ -0,0 +1,27 @@
+import { TestContext } from "./TestContext.js";
+import { vfs_xOpen } from "./vfs_xOpen.js";
+import { vfs_xAccess } from "./vfs_xAccess.js";
+import { vfs_xClose } from "./vfs_xClose.js";
+import { vfs_xRead } from "./vfs_xRead.js";
+import { vfs_xWrite } from "./vfs_xWrite.js";
+
+const CONFIG = 'OPFSAdaptiveVFS';
+const BUILDS = ['asyncify', 'jspi'];
+
+const supportsJSPI = await TestContext.supportsJSPI();
+
+describe(CONFIG, function() {
+  for (const build of BUILDS) {
+    if (build === 'jspi' && !supportsJSPI) return;
+
+    describe(build, function() {
+      const context = new TestContext({ build, config: CONFIG });
+    
+      vfs_xAccess(context);
+      vfs_xOpen(context);
+      vfs_xClose(context);
+      vfs_xRead(context);
+      vfs_xWrite(context);
+    });
+  }
+});

package/test/OPFSAnyContextVFS.test.js

@@ -0,0 +1,27 @@
+import { TestContext } from "./TestContext.js";
+import { vfs_xOpen } from "./vfs_xOpen.js";
+import { vfs_xAccess } from "./vfs_xAccess.js";
+import { vfs_xClose } from "./vfs_xClose.js";
+import { vfs_xRead } from "./vfs_xRead.js";
+import { vfs_xWrite } from "./vfs_xWrite.js";
+
+const CONFIG = 'OPFSAnyContextVFS';
+const BUILDS = ['asyncify', 'jspi'];
+
+const supportsJSPI = await TestContext.supportsJSPI();
+
+describe(CONFIG, function() {
+  for (const build of BUILDS) {
+    if (build === 'jspi' && !supportsJSPI) return;
+
+    describe(build, function() {
+      const context = new TestContext({ build, config: CONFIG });
+    
+      vfs_xAccess(context);
+      vfs_xOpen(context);
+      vfs_xClose(context);
+      vfs_xRead(context);
+      vfs_xWrite(context);
+    });
+  }
+});

package/test/OPFSCoopSyncVFS.test.js

@@ -0,0 +1,27 @@
+import { TestContext } from "./TestContext.js";
+import { vfs_xOpen } from "./vfs_xOpen.js";
+import { vfs_xAccess } from "./vfs_xAccess.js";
+import { vfs_xClose } from "./vfs_xClose.js";
+import { vfs_xRead } from "./vfs_xRead.js";
+import { vfs_xWrite } from "./vfs_xWrite.js";
+
+const CONFIG = 'OPFSCoopSyncVFS';
+const BUILDS = ['default', 'asyncify', 'jspi'];
+
+const supportsJSPI = await TestContext.supportsJSPI();
+
+describe(CONFIG, function() {
+  for (const build of BUILDS) {
+    if (build === 'jspi' && !supportsJSPI) return;
+
+    describe(build, function() {
+      const context = new TestContext({ build, config: CONFIG });
+    
+      vfs_xAccess(context);
+      vfs_xOpen(context);
+      vfs_xClose(context);
+      vfs_xRead(context);
+      vfs_xWrite(context);
+    });
+  }
+});

package/test/OPFSPermutedVFS.test.js

@@ -0,0 +1,27 @@
+import { TestContext } from "./TestContext.js";
+import { vfs_xOpen } from "./vfs_xOpen.js";
+import { vfs_xAccess } from "./vfs_xAccess.js";
+import { vfs_xClose } from "./vfs_xClose.js";
+import { vfs_xRead } from "./vfs_xRead.js";
+import { vfs_xWrite } from "./vfs_xWrite.js";
+
+const CONFIG = 'OPFSPermutedVFS';
+const BUILDS = ['asyncify', 'jspi'];
+
+const supportsJSPI = await TestContext.supportsJSPI();
+
+describe(CONFIG, function() {
+  for (const build of BUILDS) {
+    if (build === 'jspi' && !supportsJSPI) return;
+
+    describe(build, function() {
+      const context = new TestContext({ build, config: CONFIG });
+    
+      vfs_xAccess(context);
+      vfs_xOpen(context);
+      vfs_xClose(context);
+      vfs_xRead(context);
+      vfs_xWrite(context);
+    });
+  }
+});

package/test/TestContext.js

@@ -0,0 +1,96 @@
+import * as Comlink from 'comlink';
+
+const TEST_WORKER_URL = './test-worker.js';
+const TEST_WORKER_TERMINATE = true;
+
+const mapProxyToReleaser = new WeakMap();
+const workerFinalization = new FinalizationRegistry(release => release());
+
+/**
+ * @typedef TestContextParams
+ * @property {string} [build]
+ * @property {string} [config]
+ * @property {boolean} [reset]
+ */
+
+/** @type {TestContextParams} */
+const DEFAULT_PARAMS = Object.freeze({
+  build: 'default',
+  config: 'default',
+  reset: true
+});
+
+export class TestContext {
+  #params = structuredClone(DEFAULT_PARAMS);
+
+  /**
+   * @param {TestContextParams} params 
+   */
+  constructor(params = {}) {
+    Object.assign(this.#params, params);
+  }
+
+  async create(extras = {}) {
+    const url = new URL(TEST_WORKER_URL, import.meta.url);
+    for (const [key, value] of Object.entries(this.#params)) {
+      url.searchParams.set(key, value.toString());
+    }
+    for (const [key, value] of Object.entries(extras)) {
+      url.searchParams.set(key, value.toString());
+    }
+
+    const worker = new Worker(url, { type: 'module' });
+    const port = await new Promise(resolve => {
+      worker.addEventListener('message', (event) => {
+        if (event.ports[0]) {
+          return resolve(event.ports[0]);
+        }
+        const e = new Error(event.data.message);
+        throw Object.assign(e, event.data);
+      }, { once: true });
+    });
+
+    const proxy = Comlink.wrap(port);
+    if (TEST_WORKER_TERMINATE) {
+      function releaser() {
+        worker.terminate();
+      }
+      mapProxyToReleaser.set(proxy, releaser);
+      workerFinalization.register(proxy, releaser);
+    }
+
+    return proxy;
+  }
+
+  async destroy(proxy) {
+    proxy[Comlink.releaseProxy]();
+    const releaser = mapProxyToReleaser.get(proxy);
+    if (releaser) {
+      workerFinalization.unregister(releaser);
+      releaser();
+    }
+  }
+
+  // https://github.com/WebAssembly/js-promise-integration/issues/21#issuecomment-1634843621
+  static async supportsJSPI() {
+    try {
+      const m = new Uint8Array([
+        0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 111, 0, 3, 2, 1, 0, 7, 5, 1,
+        1, 111, 0, 0, 10, 4, 1, 2, 0, 11,
+      ]);
+      const { instance } = await WebAssembly.instantiate(m);
+      // @ts-ignore
+      new WebAssembly.Function(
+        {
+          parameters: [],
+          results: ["externref"],
+        },
+        instance.exports.o,
+        { promising: "first" }
+      );
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+}