@livestore/wa-sqlite 0.4.0-dev.21 → 0.4.0-dev.23

package/test/sql_0005.js

@@ -1,75 +1,91 @@
-import * as Comlink from 'comlink';
+import * as Comlink from 'comlink'
 
 export function sql_0005(context) {
-  describe('sql_0005', function() {
-    beforeAll(async function() {
+  describe('sql_0005', function () {
+    beforeAll(async function () {
       // Clear persistent storage.
-      const proxy = await context.create();
-      await context.destroy(proxy);
-    });
-  
-    const cleanup = [];
-    beforeEach(async function() {
-      cleanup.splice(0);
-    });
-  
-    afterEach(async function() {
+      const proxy = await context.create()
+      await context.destroy(proxy)
+    })
+
+    const cleanup = []
+    beforeEach(async function () {
+      cleanup.splice(0)
+    })
+
+    afterEach(async function () {
       for (const fn of cleanup) {
-        await fn();
+        await fn()
       }
-    });
-  
-    it('should transact atomically', async function() {
-      const instances = [];
+    })
+
+    it('should transact atomically', async function () {
+      const instances = []
       for (let i = 0; i < 8; ++i) {
-        const proxy = await context.create({ reset: false });
-        const sqlite3 = proxy.sqlite3;
-        const db = await sqlite3.open_v2('demo');
-        instances.push({ sqlite3, db });
+        const proxy = await context.create({ reset: false })
+        const sqlite3 = proxy.sqlite3
+        const db = await sqlite3.open_v2('demo')
+        instances.push({ sqlite3, db })
         cleanup.push(async () => {
-          await sqlite3.close(db);
-          await context.destroy(proxy);
-        });
+          await sqlite3.close(db)
+          await context.destroy(proxy)
+        })
 
         if (i === 0) {
-          await sqlite3.exec(db, `
+          await sqlite3.exec(
+            db,
+            `
             BEGIN IMMEDIATE;
             CREATE TABLE IF NOT EXISTS t(key PRIMARY KEY, value);
             INSERT OR IGNORE INTO t VALUES ('foo', 0);
             COMMIT;
-          `);
+          `,
+          )
         }
       }
 
-      const iterations = 32;
-      const values = new Set();
-      await Promise.all(instances.map(async instance => {
-        for (let i = 0; i < iterations; ++i) {
-          const rows = await transact(instance, `
+      const iterations = 32
+      const values = new Set()
+      await Promise.all(
+        instances.map(async (instance) => {
+          for (let i = 0; i < iterations; ++i) {
+            const rows = await transact(
+              instance,
+              `
             BEGIN IMMEDIATE;
             UPDATE t SET value = value + 1 WHERE key = 'foo';
             SELECT value FROM t WHERE key = 'foo';
             COMMIT;
-          `);
-          values.add(rows[0][0]);
-        }
-      }));
+          `,
+            )
+            values.add(rows[0][0])
+          }
+        }),
+      )
 
-      expect(values.size).toBe(instances.length * iterations);
-      expect(Array.from(values).sort((a, b) => b - a).at(0)).toBe(values.size);
-    });
-  });
+      expect(values.size).toBe(instances.length * iterations)
+      expect(
+        Array.from(values)
+          .sort((a, b) => b - a)
+          .at(0),
+      ).toBe(values.size)
+    })
+  })
 }
 
 async function transact({ sqlite3, db }, sql) {
   while (true) {
     try {
-      const rows = [];
-      await sqlite3.exec(db, sql, Comlink.proxy(row => rows.push(row)));
-      return rows;
+      const rows = []
+      await sqlite3.exec(
+        db,
+        sql,
+        Comlink.proxy((row) => rows.push(row)),
+      )
+      return rows
     } catch (e) {
       if (e.message !== 'database is locked') {
-        throw e;
+        throw e
       }
     }
   }

package/test/test-worker.js

@@ -1,204 +1,212 @@
 // Copyright 2024 Roy T. Hashimoto. All Rights Reserved.
 
-import * as Comlink from 'comlink';
-import * as SQLite from '../src/sqlite-api.js';
+import * as Comlink from 'comlink'
+
+import * as SQLite from '../src/sqlite-api.js'
 
 const BUILDS = new Map([
   ['default', '../dist/wa-sqlite.mjs'],
   ['asyncify', '../dist/wa-sqlite-async.mjs'],
   ['jspi', '../dist/wa-sqlite-jspi.mjs'],
-]);
-
-const MODULE = Symbol('module');
-const VFS_CONFIGS = new Map([
-  {
-    name: 'default',
-    vfsModule: null
-  },
-  {
-    name: 'AccessHandlePoolVFS',
-    vfsModule: '../src/examples/AccessHandlePoolVFS.js',
-  },
-  {
-    name: 'OPFSCoopSyncVFS',
-    vfsModule: '../src/examples/OPFSCoopSyncVFS.js',
-  },
-  {
-    name: 'FLOOR',
-    vfsModule: '../src/examples/FLOOR.js',
-  },
-  {
-    name: 'MemoryVFS',
-    vfsModule: '../src/examples/MemoryVFS.js',
-  },
-  {
-    name: 'MemoryAsyncVFS',
-    vfsModule: '../src/examples/MemoryAsyncVFS.js',
-  },
-  {
-    name: 'IDBBatchAtomicVFS',
-    vfsModule: '../src/examples/IDBBatchAtomicVFS.js',
-  },
-  {
-    name: 'IDBMirrorVFS',
-    vfsModule: '../src/examples/IDBMirrorVFS.js',
-  },
-  {
-    name: 'OPFSAdaptiveVFS',
-    vfsModule: '../src/examples/OPFSAdaptiveVFS.js',
-  },
-  {
-    name: 'OPFSAnyContextVFS',
-    vfsModule: '../src/examples/OPFSAnyContextVFS.js',
-  },
-  {
-    name: 'OPFSPermutedVFS',
-    vfsModule: '../src/examples/OPFSPermutedVFS.js',
-  },
-].map(config => [config.name, config]));
-
-const INDEXEDDB_DBNAMES = ['demo'];
-
-const searchParams = new URLSearchParams(location.search);
-
-maybeReset().then(async () => {
-  const buildName = searchParams.get('build') || BUILDS.keys().next().value;
-  const configName = searchParams.get('config') || VFS_CONFIGS.keys().next().value;
-  const config = VFS_CONFIGS.get(configName);
-
-  // Instantiate SQLite.
-  const { default: moduleFactory } = await import(BUILDS.get(buildName));
-  const module = await moduleFactory();
-  const sqlite3 = SQLite.Factory(module);
-
-  const vfs = await (async function() {
-    if (config.vfsModule) {
-      // Create the VFS and register it as the default file system.
-      const namespace = await import(config.vfsModule);
-      const className = config.vfsClass ?? config.vfsModule.match(/([^/]+)\.js$/)[1];
-      const vfsArgs = (config.vfsArgs ?? ['demo', MODULE])
-        .map(arg => arg === MODULE ? module : arg);
-      const vfs = await namespace[className].create(...vfsArgs);
-      sqlite3.vfs_register(vfs, true);
-      return vfs;
-    }
-    return {};
-  })();
-
-  const sqlite3Proxy = new Proxy(sqlite3, {
-    get(target, p, receiver) {
-      // Comlink intercepts some function property names, e.g. "bind",
-      // so allow aliases to avoid the problem.
-      if (typeof p === 'string') p = p.replaceAll('$', '');
-
-      const value = Reflect.get(target, p, receiver);
-      if (typeof value === 'function') {
-        return async (...args) => {
-          const result = await value.apply(target, args);
-          if (p === 'statements') {
-            return Comlink.proxy(result);
-          }
-          return result;
-        };
+])
+
+const MODULE = Symbol('module')
+const VFS_CONFIGS = new Map(
+  [
+    {
+      name: 'default',
+      vfsModule: null,
+    },
+    {
+      name: 'AccessHandlePoolVFS',
+      vfsModule: '../src/examples/AccessHandlePoolVFS.js',
+    },
+    {
+      name: 'OPFSCoopSyncVFS',
+      vfsModule: '../src/examples/OPFSCoopSyncVFS.js',
+    },
+    {
+      name: 'FLOOR',
+      vfsModule: '../src/examples/FLOOR.js',
+    },
+    {
+      name: 'MemoryVFS',
+      vfsModule: '../src/examples/MemoryVFS.js',
+    },
+    {
+      name: 'MemoryAsyncVFS',
+      vfsModule: '../src/examples/MemoryAsyncVFS.js',
+    },
+    {
+      name: 'IDBBatchAtomicVFS',
+      vfsModule: '../src/examples/IDBBatchAtomicVFS.js',
+    },
+    {
+      name: 'IDBMirrorVFS',
+      vfsModule: '../src/examples/IDBMirrorVFS.js',
+    },
+    {
+      name: 'OPFSAdaptiveVFS',
+      vfsModule: '../src/examples/OPFSAdaptiveVFS.js',
+    },
+    {
+      name: 'OPFSAnyContextVFS',
+      vfsModule: '../src/examples/OPFSAnyContextVFS.js',
+    },
+    {
+      name: 'OPFSPermutedVFS',
+      vfsModule: '../src/examples/OPFSPermutedVFS.js',
+    },
+  ].map((config) => [config.name, config]),
+)
+
+const INDEXEDDB_DBNAMES = ['demo']
+
+const searchParams = new URLSearchParams(location.search)
+
+maybeReset()
+  .then(async () => {
+    const buildName = searchParams.get('build') || BUILDS.keys().next().value
+    const configName = searchParams.get('config') || VFS_CONFIGS.keys().next().value
+    const config = VFS_CONFIGS.get(configName)
+
+    // Instantiate SQLite.
+    const { default: moduleFactory } = await import(BUILDS.get(buildName))
+    const module = await moduleFactory()
+    const sqlite3 = SQLite.Factory(module)
+
+    const vfs = await (async function () {
+      if (config.vfsModule) {
+        // Create the VFS and register it as the default file system.
+        const namespace = await import(config.vfsModule)
+        const className = config.vfsClass ?? config.vfsModule.match(/([^/]+)\.js$/)[1]
+        const vfsArgs = (config.vfsArgs ?? ['demo', MODULE]).map((arg) => (arg === MODULE ? module : arg))
+        const vfs = await namespace[className].create(...vfsArgs)
+        sqlite3.vfs_register(vfs, true)
+        return vfs
       }
-    }
-  });
-
-  const vfsProxy = new Proxy(vfs, {
-    get(target, p, receiver) {
-      const value = Reflect.get(target, p, receiver);
-      if (typeof value === 'function') {
-        return async (...args) => {
-          if (p === 'jRead') {
-            // The read buffer Uint8Array will be passed by proxy so all
-            // access is asynchronous. Pass a local buffer to the VFS
-            // and copy the local buffer to the proxy on completion.
-            const proxyBuffer = args[1];
-            args[1] = new Uint8Array(await proxyBuffer.length);
-            const result = await value.apply(target, args);
-            await proxyBuffer.set(args[1]);
-            return result;
+      return {}
+    })()
+
+    const sqlite3Proxy = new Proxy(sqlite3, {
+      get(target, p, receiver) {
+        // Comlink intercepts some function property names, e.g. "bind",
+        // so allow aliases to avoid the problem.
+        if (typeof p === 'string') p = p.replaceAll('$', '')
+
+        const value = Reflect.get(target, p, receiver)
+        if (typeof value === 'function') {
+          return async (...args) => {
+            const result = await value.apply(target, args)
+            if (p === 'statements') {
+              return Comlink.proxy(result)
+            }
+            return result
           }
-          return value.apply(target, args);
-        };
-      }
-    }
-  });
-
-  const { port1, port2 } = new MessageChannel();
-  Comlink.expose({
-    module,
-    sqlite3: sqlite3Proxy,
-    vfs: vfsProxy,
-  }, port1);
-  postMessage(null, [port2]);
-}).catch(e => {
-  console.error(e);
-  postMessage(cvtErrorToCloneable(e));
-});
+        }
+      },
+    })
+
+    const vfsProxy = new Proxy(vfs, {
+      get(target, p, receiver) {
+        const value = Reflect.get(target, p, receiver)
+        if (typeof value === 'function') {
+          return async (...args) => {
+            if (p === 'jRead') {
+              // The read buffer Uint8Array will be passed by proxy so all
+              // access is asynchronous. Pass a local buffer to the VFS
+              // and copy the local buffer to the proxy on completion.
+              const proxyBuffer = args[1]
+              args[1] = new Uint8Array(await proxyBuffer.length)
+              const result = await value.apply(target, args)
+              await proxyBuffer.set(args[1])
+              return result
+            }
+            return value.apply(target, args)
+          }
+        }
+      },
+    })
+
+    const { port1, port2 } = new MessageChannel()
+    Comlink.expose(
+      {
+        module,
+        sqlite3: sqlite3Proxy,
+        vfs: vfsProxy,
+      },
+      port1,
+    )
+    postMessage(null, [port2])
+  })
+  .catch((e) => {
+    console.error(e)
+    postMessage(cvtErrorToCloneable(e))
+  })
 
 async function maybeReset() {
   if (searchParams.get('reset') !== 'true') {
-    return;
-  }  
-  
+    return
+  }
+
   // Limit the amount of time in this function.
-  const abortController = new AbortController();
-  setTimeout(() => abortController.abort(), 10_000);
+  const abortController = new AbortController()
+  setTimeout(() => abortController.abort(), 10_000)
 
   // Clear OPFS.
-  const root = await navigator.storage?.getDirectory();
+  const root = await navigator.storage?.getDirectory()
   if (root) {
-    let opfsDeleted = false;
+    let opfsDeleted = false
     while (!opfsDeleted) {
-      abortController.signal.throwIfAborted();
+      abortController.signal.throwIfAborted()
       try {
         // @ts-ignore
         for await (const name of root.keys()) {
-          await root.removeEntry(name, { recursive: true });
+          await root.removeEntry(name, { recursive: true })
         }
-        opfsDeleted = true;
+        opfsDeleted = true
       } catch (e) {
         // A NoModificationAllowedError is thrown if an entry can't be
         // deleted because it isn't closed. Just try again.
         if (e.name === 'NoModificationAllowedError') {
-          await new Promise(resolve => setTimeout(resolve));
-          continue;
+          await new Promise((resolve) => setTimeout(resolve))
+          continue
         }
-        throw e;
+        throw e
       }
     }
   }
 
   // Clear IndexedDB.
-  const dbList = indexedDB.databases ?
-    await indexedDB.databases() :
-    INDEXEDDB_DBNAMES.map(name => ({ name }));
-  await Promise.all(dbList.map(({name}) => {
-    return new Promise((resolve, reject) => {
-      const request = indexedDB.deleteDatabase(name);
-      request.onsuccess = resolve;
-      request.onerror = reject;
-    });
-  }));
+  const dbList = indexedDB.databases ? await indexedDB.databases() : INDEXEDDB_DBNAMES.map((name) => ({ name }))
+  await Promise.all(
+    dbList.map(({ name }) => {
+      return new Promise((resolve, reject) => {
+        const request = indexedDB.deleteDatabase(name)
+        request.onsuccess = resolve
+        request.onerror = reject
+      })
+    }),
+  )
 }
 
 function cvtErrorToCloneable(e) {
   if (e instanceof Error) {
     const props = new Set([
-      ...['name', 'message', 'stack'].filter(k => e[k] !== undefined),
-      ...Object.getOwnPropertyNames(e)
-    ]);
-    return Object.fromEntries(Array.from(props, k =>  [k, e[k]])
-      .filter(([_, v]) => {
+      ...['name', 'message', 'stack'].filter((k) => e[k] !== undefined),
+      ...Object.getOwnPropertyNames(e),
+    ])
+    return Object.fromEntries(
+      Array.from(props, (k) => [k, e[k]]).filter(([_, v]) => {
         // Skip any non-cloneable properties.
         try {
-          structuredClone(v);
-          return true;
+          structuredClone(v)
+          return true
         } catch (e) {
-          return false;
+          return false
         }
-      }));
+      }),
+    )
   }
-  return e;
-}
+  return e
+}

package/test/vfs_xAccess.js

@@ -1,2 +1 @@
-export function vfs_xAccess(context) {
-}
+export function vfs_xAccess(context) {}

package/test/vfs_xClose.js

@@ -1,52 +1,53 @@
-import * as Comlink from 'comlink';
-import * as VFS from '../src/VFS.js';
+import * as Comlink from 'comlink'
 
-const FILEID = 1;
+import * as VFS from '../src/VFS.js'
+
+const FILEID = 1
 
 export function vfs_xClose(context) {
-  describe('vfs_xClose', function() {
-    let proxy, vfs;
-    beforeEach(async function() {
-      proxy = await context.create();
-      vfs = proxy.vfs;
-    });
-
-    afterEach(async function() {
-      await context.destroy(proxy);
-    });
-
-    it('should leave an accessible file', async function() {
-      let rc;
-      const pOpenOutput = Comlink.proxy(new DataView(new ArrayBuffer(4)));
-      const openFlags = VFS.SQLITE_OPEN_CREATE | VFS.SQLITE_OPEN_READWRITE;
-      rc = await vfs.jOpen('test', FILEID, openFlags, pOpenOutput);
-      expect(rc).toEqual(VFS.SQLITE_OK);
-
-      await vfs.jClose(FILEID);
-
-      const pAccessOutput = Comlink.proxy(new DataView(new ArrayBuffer(4)));
-      rc = await vfs.jAccess('test', VFS.SQLITE_ACCESS_READWRITE, pAccessOutput);
-      expect(rc).toEqual(VFS.SQLITE_OK);
-      expect(pAccessOutput.getInt32(0, true)).not.toEqual(0);
-    });
-
-    it('should delete on close', async function() {
-      let rc;
-      const pOpenOutput = Comlink.proxy(new DataView(new ArrayBuffer(4)));
-      const openFlags = VFS.SQLITE_OPEN_CREATE | VFS.SQLITE_OPEN_READWRITE | VFS.SQLITE_OPEN_DELETEONCLOSE;
-      rc = await vfs.jOpen('test', FILEID, openFlags, pOpenOutput);
-      expect(rc).toEqual(VFS.SQLITE_OK);
-
-      const pAccessOutput = Comlink.proxy(new DataView(new ArrayBuffer(4)));
-      rc = await vfs.jAccess('test', VFS.SQLITE_ACCESS_READWRITE, pAccessOutput);
-      expect(rc).toEqual(VFS.SQLITE_OK);
-      expect(pAccessOutput.getInt32(0, true)).toEqual(1);
-
-      await vfs.jClose(FILEID);
-
-      rc = await vfs.jAccess('test', VFS.SQLITE_ACCESS_READWRITE, pAccessOutput);
-      expect(rc).toEqual(VFS.SQLITE_OK);
-      expect(pAccessOutput.getInt32(0, true)).toEqual(0);
-    });
-  });
-}
+  describe('vfs_xClose', function () {
+    let proxy, vfs
+    beforeEach(async function () {
+      proxy = await context.create()
+      vfs = proxy.vfs
+    })
+
+    afterEach(async function () {
+      await context.destroy(proxy)
+    })
+
+    it('should leave an accessible file', async function () {
+      let rc
+      const pOpenOutput = Comlink.proxy(new DataView(new ArrayBuffer(4)))
+      const openFlags = VFS.SQLITE_OPEN_CREATE | VFS.SQLITE_OPEN_READWRITE
+      rc = await vfs.jOpen('test', FILEID, openFlags, pOpenOutput)
+      expect(rc).toEqual(VFS.SQLITE_OK)
+
+      await vfs.jClose(FILEID)
+
+      const pAccessOutput = Comlink.proxy(new DataView(new ArrayBuffer(4)))
+      rc = await vfs.jAccess('test', VFS.SQLITE_ACCESS_READWRITE, pAccessOutput)
+      expect(rc).toEqual(VFS.SQLITE_OK)
+      expect(pAccessOutput.getInt32(0, true)).not.toEqual(0)
+    })
+
+    it('should delete on close', async function () {
+      let rc
+      const pOpenOutput = Comlink.proxy(new DataView(new ArrayBuffer(4)))
+      const openFlags = VFS.SQLITE_OPEN_CREATE | VFS.SQLITE_OPEN_READWRITE | VFS.SQLITE_OPEN_DELETEONCLOSE
+      rc = await vfs.jOpen('test', FILEID, openFlags, pOpenOutput)
+      expect(rc).toEqual(VFS.SQLITE_OK)
+
+      const pAccessOutput = Comlink.proxy(new DataView(new ArrayBuffer(4)))
+      rc = await vfs.jAccess('test', VFS.SQLITE_ACCESS_READWRITE, pAccessOutput)
+      expect(rc).toEqual(VFS.SQLITE_OK)
+      expect(pAccessOutput.getInt32(0, true)).toEqual(1)
+
+      await vfs.jClose(FILEID)
+
+      rc = await vfs.jAccess('test', VFS.SQLITE_ACCESS_READWRITE, pAccessOutput)
+      expect(rc).toEqual(VFS.SQLITE_OK)
+      expect(pAccessOutput.getInt32(0, true)).toEqual(0)
+    })
+  })
+}