@livestore/wa-sqlite 1.0.5-dev.2 → 1.0.8-dev.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/wa-sqlite",
-  "version": "1.0.5-dev.2",
+  "version": "1.0.8-dev.2",
   "type": "module",
   "main": "src/sqlite-api.js",
   "types": "src/types/index.d.ts",
@@ -18,8 +18,8 @@
   "devDependencies": {
     "@types/jasmine": "^5.1.4",
     "@web/dev-server": "^0.4.6",
-    "@web/test-runner": "^0.18.2",
-    "@web/test-runner-core": "^0.13.3",
+    "@web/test-runner": "^0.20.0",
+    "@web/test-runner-core": "^0.13.4",
     "comlink": "^4.4.1",
     "jasmine-core": "^4.5.0",
     "monaco-editor": "^0.34.1",

package/src/FacadeVFS.js

@@ -405,64 +405,30 @@ export class FacadeVFS extends VFS.Base {
 
   /**
    * Wrapped DataView for pointer arguments.
-   * Pointers to a single value are passed using DataView. A Proxy
-   * wrapper prevents use of incorrect type or endianness.
+   * Pointers to a single value are passed using a DataView-like class.
+   * This wrapper class prevents use of incorrect type or endianness, and
+   * reacquires the underlying buffer when the WebAssembly memory is resized.
    * @param {'Int32'|'BigInt64'} type 
    * @param {number} byteOffset 
    * @returns {DataView}
    */
   #makeTypedDataView(type, byteOffset) {
-    const byteLength = type === 'Int32' ? 4 : 8;
-    const getter = `get${type}`;
-    const setter = `set${type}`;
-    const makeDataView = () => new DataView(
-      this._module.HEAPU8.buffer,
-      this._module.HEAPU8.byteOffset + byteOffset,
-      byteLength);
-    let dataView = makeDataView();
-    return new Proxy(dataView, {
-      get(_, prop) {
-        if (dataView.buffer.byteLength === 0) {
-          // WebAssembly memory resize detached the buffer.
-          dataView = makeDataView();
-        }
-        if (prop === getter) {
-          return function(byteOffset, littleEndian) {
-            if (!littleEndian) throw new Error('must be little endian');
-            return dataView[prop](byteOffset, littleEndian);
-          }
-        }
-        if (prop === setter) {
-          return function(byteOffset, value, littleEndian) {
-            if (!littleEndian) throw new Error('must be little endian');
-            return dataView[prop](byteOffset, value, littleEndian);
-          }
-        }
-        if (typeof prop === 'string' && (prop.match(/^(get)|(set)/))) {
-          throw new Error('invalid type');
-        }
-        const result = dataView[prop];
-        return typeof result === 'function' ? result.bind(dataView) : result;
-      }
-    });
+    // @ts-ignore
+    return new DataViewProxy(this._module, byteOffset, type);
   }
 
   /**
+   * Wrapped Uint8Array for buffer arguments.
+   * Memory blocks are passed as a Uint8Array-like class. This wrapper
+   * class reacquires the underlying buffer when the WebAssembly memory
+   * is resized.
    * @param {number} byteOffset 
    * @param {number} byteLength 
+   * @returns {Uint8Array}
    */
   #makeDataArray(byteOffset, byteLength) {
-    let target = this._module.HEAPU8.subarray(byteOffset, byteOffset + byteLength);
-    return new Proxy(target, {
-      get: (_, prop, receiver) => {
-        if (target.buffer.byteLength === 0) {
-          // WebAssembly memory resize detached the buffer.
-          target = this._module.HEAPU8.subarray(byteOffset, byteOffset + byteLength);
-        }
-        const result = target[prop];
-        return typeof result === 'function' ? result.bind(target) : result;
-      }
-    });
+    // @ts-ignore
+    return new Uint8ArrayProxy(this._module, byteOffset, byteLength);
   }
 
   #decodeFilename(zName, flags) {
@@ -506,3 +472,210 @@ export class FacadeVFS extends VFS.Base {
 function delegalize(lo32, hi32) {
   return (hi32 * 0x100000000) + lo32 + (lo32 < 0 ? 2**32 : 0);
 }
+
+// This class provides a Uint8Array-like interface for a WebAssembly memory
+// buffer. It is used to access memory blocks passed as arguments to
+// xRead, xWrite, etc. The class reacquires the underlying buffer when the
+// WebAssembly memory is resized, which can happen when the memory is
+// detached and resized by the WebAssembly module.
+//
+// Note that although this class implements the same methods as Uint8Array,
+// it is not a real Uint8Array and passing it to functions that expect
+// a Uint8Array may not work. Use subarray() to get a real Uint8Array
+// if needed.
+class Uint8ArrayProxy {
+  #module;
+
+  #_array = new Uint8Array()
+  get #array() {
+    if (this.#_array.buffer.byteLength === 0) {
+      // WebAssembly memory resize detached the buffer so re-create the
+      // array with the new buffer.
+      this.#_array = this.#module.HEAPU8.subarray(
+        this.byteOffset,
+        this.byteOffset + this.byteLength);
+    }
+    return this.#_array;
+  }
+
+  /**
+   * @param {*} module
+   * @param {number} byteOffset 
+   * @param {number} byteLength 
+   */
+  constructor(module, byteOffset, byteLength) {
+    this.#module = module;
+    this.byteOffset = byteOffset;
+    this.length = this.byteLength = byteLength;
+  }
+
+  get buffer() {
+    return this.#array.buffer;
+  }
+
+  at(index) {
+    return this.#array.at(index);
+  }
+  copyWithin(target, start, end) {
+    this.#array.copyWithin(target, start, end);
+  }
+  entries() {
+    return this.#array.entries();
+  }
+  every(predicate) {
+    return this.#array.every(predicate);
+  }
+  fill(value, start, end) {
+    this.#array.fill(value, start, end);
+  }
+  filter(predicate) {
+    return this.#array.filter(predicate);
+  }
+  find(predicate) {
+    return this.#array.find(predicate);
+  }
+  findIndex(predicate) {
+    return this.#array.findIndex(predicate);
+  }
+  findLast(predicate) {
+    return this.#array.findLast(predicate);
+  }
+  findLastIndex(predicate) {
+    return this.#array.findLastIndex(predicate);
+  }
+  forEach(callback) {
+    this.#array.forEach(callback);
+  }
+  includes(value, start) {
+    return this.#array.includes(value, start);
+  }
+  indexOf(value, start) {
+    return this.#array.indexOf(value, start);
+  }
+  join(separator) {
+    return this.#array.join(separator);
+  }
+  keys() {
+    return this.#array.keys();
+  }
+  lastIndexOf(value, start) {
+    return this.#array.lastIndexOf(value, start);
+  }
+  map(callback) {
+    return this.#array.map(callback);
+  }
+  reduce(callback, initialValue) {
+    return this.#array.reduce(callback, initialValue);
+  }
+  reduceRight(callback, initialValue) {
+    return this.#array.reduceRight(callback, initialValue);
+  }
+  reverse() {
+    this.#array.reverse();
+  }
+  set(array, offset) {
+    this.#array.set(array, offset);
+  }
+  slice(start, end) {
+    return this.#array.slice(start, end);
+  }
+  some(predicate) {
+    return this.#array.some(predicate);
+  }
+  sort(compareFn) {
+    this.#array.sort(compareFn);
+  }
+  subarray(begin, end) {
+    return this.#array.subarray(begin, end);
+  }
+  toLocaleString(locales, options) {
+    // @ts-ignore
+    return this.#array.toLocaleString(locales, options);
+  }
+  toReversed() {
+    return this.#array.toReversed();
+  }
+  toSorted(compareFn) {
+    return this.#array.toSorted(compareFn);
+  }
+  toString() {
+    return this.#array.toString();
+  }
+  values() {
+    return this.#array.values();
+  }
+  with(index, value) {
+    return this.#array.with(index, value);
+  }
+  [Symbol.iterator]() {
+    return this.#array[Symbol.iterator]();
+  }
+}
+
+// This class provides a DataView-like interface for a WebAssembly memory
+// buffer, restricted to either Int32 or BigInt64 types. It also reacquires
+// the underlying buffer when the WebAssembly memory is resized, which can
+// happen when the memory is detached and resized by the WebAssembly module.
+class DataViewProxy {
+  #module;
+  #type;
+
+  #_view = new DataView(new ArrayBuffer(0));
+  get #view() {
+    if (this.#_view.buffer.byteLength === 0) {
+      // WebAssembly memory resize detached the buffer so re-create the
+      // view with the new buffer.
+      this.#_view = new DataView(
+        this.#module.HEAPU8.buffer,
+        this.#module.HEAPU8.byteOffset + this.byteOffset);
+    }
+    return this.#_view;
+  }
+
+  /**
+   * @param {*} module
+   * @param {number} byteOffset 
+   * @param {'Int32'|'BigInt64'} type
+   */
+  constructor(module, byteOffset, type) {
+    this.#module = module;
+    this.byteOffset = byteOffset;
+    this.#type = type;
+  }
+
+  get buffer() {
+    return this.#view.buffer;
+  }
+  get byteLength() {
+    return this.#type === 'Int32' ? 4 : 8;
+  }
+
+  getInt32(byteOffset, littleEndian) {
+    if (this.#type !== 'Int32') {
+      throw new Error('invalid type');
+    }
+    if (!littleEndian) throw new Error('must be little endian');
+    return this.#view.getInt32(byteOffset, littleEndian);
+  }
+  setInt32(byteOffset, value, littleEndian) {
+    if (this.#type !== 'Int32') {
+      throw new Error('invalid type');
+    }
+    if (!littleEndian) throw new Error('must be little endian');
+    this.#view.setInt32(byteOffset, value, littleEndian);
+  }
+  getBigInt64(byteOffset, littleEndian) {
+    if (this.#type !== 'BigInt64') {
+      throw new Error('invalid type');
+    }
+    if (!littleEndian) throw new Error('must be little endian');
+    return this.#view.getBigInt64(byteOffset, littleEndian);
+  }
+  setBigInt64(byteOffset, value, littleEndian) {
+    if (this.#type !== 'BigInt64') {
+      throw new Error('invalid type');
+    }
+    if (!littleEndian) throw new Error('must be little endian');
+    this.#view.setBigInt64(byteOffset, value, littleEndian);
+  }
+}

package/src/examples/IDBBatchAtomicVFS.js

@@ -3,6 +3,11 @@ import { FacadeVFS } from '../FacadeVFS.js';
 import * as VFS from '../VFS.js';
 import { WebLocksMixin } from '../WebLocksMixin.js';
 
+const RETRYABLE_ERRORS = new Set([
+  'TransactionInactiveError',
+  'InvalidStateError'
+]);
+
 /**
  * @typedef Metadata
  * @property {string} name
@@ -482,25 +487,27 @@ export class IDBBatchAtomicVFS extends WebLocksMixin(FacadeVFS) {
           break;
         case VFS.SQLITE_FCNTL_SYNC:
           this.log?.('xFileControl', file.path, 'SYNC');
-          const commitMetadata = Object.assign({}, file.metadata);
-          const prevFileSize = file.rollback.fileSize
-          this.#idb.q(({ metadata, blocks }) => {
-            metadata.put(commitMetadata);
-
-            // Remove old page versions.
-            for (const offset of file.changedPages) {
-              if (offset < prevFileSize) {
-                const range = IDBKeyRange.bound(
-                  [file.path, -offset, commitMetadata.version],
-                  [file.path, -offset, Infinity],
-                  true);
-                blocks.delete(range);
+          if (file.rollback) {
+            const commitMetadata = Object.assign({}, file.metadata);
+            const prevFileSize = file.rollback.fileSize
+            this.#idb.q(({ metadata, blocks }) => {
+              metadata.put(commitMetadata);
+
+              // Remove old page versions.
+              for (const offset of file.changedPages) {
+                if (offset < prevFileSize) {
+                  const range = IDBKeyRange.bound(
+                    [file.path, -offset, commitMetadata.version],
+                    [file.path, -offset, Infinity],
+                    true);
+                  blocks.delete(range);
+                }
               }
-            }
-            file.changedPages.clear();
-          }, 'rw', file.txOptions);
-          file.needsMetadataSync = false;
-          file.rollback = null;
+              file.changedPages.clear();
+            }, 'rw', file.txOptions);
+            file.needsMetadataSync = false;
+            file.rollback = null;
+          }
           break;
         case VFS.SQLITE_FCNTL_BEGIN_ATOMIC_WRITE:
           // Every write transaction is atomic, so this is a no-op.
@@ -717,21 +724,21 @@ export class IDBContext {
         });
       }
 
-      // @ts-ignore
-      // Create object store proxies.
-      const objectStores = [...tx.objectStoreNames].map(name => {
-        return [name, this.proxyStoreOrIndex(tx.objectStore(name))];
-      });
-
       try {
+        // @ts-ignore
+        // Create object store proxies.
+        const objectStores = [...tx.objectStoreNames].map(name => {
+          return [name, this.proxyStoreOrIndex(tx.objectStore(name))];
+        });
+
         // Execute the function.
         return await f(Object.fromEntries(objectStores));
       } catch (e) {
         // Use a new transaction if this one was inactive. This will
         // happen if the last request in the transaction completed
         // in a previous task but the transaction has not yet committed.
-        if (!i && e.name === 'TransactionInactiveError') {
-          this.log?.('TransactionInactiveError, retrying');
+        if (!i && RETRYABLE_ERRORS.has(e.name)) {
+          this.log?.(`${e.name}, retrying`);
           tx = null;
           continue;
         }

package/src/examples/IDBMirrorVFS.js

@@ -333,6 +333,12 @@ export class IDBMirrorVFS extends FacadeVFS {
 
       if (file.flags & VFS.SQLITE_OPEN_MAIN_DB) {
         this.#requireTxActive(file);
+        // SQLite is not necessarily written sequentially, so fill in the
+        // unwritten blocks here.
+        for (let fillOffset = file.txActive.fileSize;
+             fillOffset < iOffset; fillOffset += pData.byteLength) {
+          file.txActive.blocks.set(fillOffset, new Uint8Array(pData.byteLength));
+        }
         file.txActive.blocks.set(iOffset, pData.slice());
         file.txActive.fileSize = Math.max(file.txActive.fileSize, iOffset + pData.byteLength);
         file.blockSize = pData.byteLength;

package/src/examples/MemoryVFS.js

@@ -116,7 +116,7 @@ export class MemoryVFS extends FacadeVFS {
     }
 
     // Copy data.
-    new Uint8Array(file.data, iOffset, pData.byteLength).set(pData);
+    new Uint8Array(file.data, iOffset, pData.byteLength).set(pData.subarray());
     file.size = Math.max(file.size, iOffset + pData.byteLength);
     return VFS.SQLITE_OK;
   }

package/src/examples/OPFSCoopSyncVFS.js

@@ -437,7 +437,7 @@ export class OPFSCoopSyncVFS extends FacadeVFS {
         if (file.persistentFile.isHandleRequested) {
             // Another connection wants the access handle.
           this.#releaseAccessHandle(file);
-          this.isHandleRequested = false;
+          file.persistentFile.isHandleRequested = false;
         }
         file.persistentFile.isFileLocked = false;
       }

package/src/sqlite-api.js

@@ -35,11 +35,12 @@ export function Factory(Module) {
   const tmp = Module._malloc(8);
   const tmpPtr = [tmp, tmp + 4];
 
+  const textEncoder = new TextEncoder();
   // Convert a JS string to a C string. sqlite3_malloc is used to allocate
   // memory (use sqlite3_free to deallocate).
   function createUTF8(s) {
     if (typeof s !== 'string') return 0;
-    const utf8 = new TextEncoder().encode(s);
+    const utf8 = textEncoder.encode(s);
     const zts = Module._sqlite3_malloc(utf8.byteLength + 1);
     Module.HEAPU8.set(utf8, zts);
     Module.HEAPU8[zts + utf8.byteLength] = 0;
@@ -119,6 +120,8 @@ export function Factory(Module) {
         }
       case 'string':
         return sqlite3.bind_text(stmt, i, value);
+      case "boolean":
+        return sqlite3.bind_int(stmt, i, value ? 1 : 0);
       default:
         if (value instanceof Uint8Array || Array.isArray(value)) {
           return sqlite3.bind_blob(stmt, i, value);
@@ -499,7 +502,6 @@ export function Factory(Module) {
           columns = columns ?? sqlite3.column_names(stmt);
           const row = sqlite3.row(stmt);
           callback(row, columns);
-          callback(row, columns);
         }
       }
     }
@@ -769,7 +771,7 @@ export function Factory(Module) {
       const onFinally = [];
       // try {
         // Encode SQL string to UTF-8.
-        const utf8 = new TextEncoder().encode(sql);
+        const utf8 = textEncoder.encode(sql);
 
         // Copy encoded string to WebAssembly memory. The SQLite docs say
         // zero-termination is a minor optimization so add room for that.

package/src/types/globals.d.ts

@@ -11,7 +11,7 @@ declare function setValue(ptr: number, value: number, type: string): number;
 declare function mergeInto(library: object, methods: object): void;
 
 declare var HEAPU8: Uint8Array;
-declare var HEAPU32: Uint32Array;
+declare var HEAP32: Int32Array;
 declare var LibraryManager;
 declare var Module;
 declare var _vfsAccess;

package/test/api_statements.js

@@ -238,6 +238,27 @@ export function api_statements(context) {
       }
     });
 
+    it('should bind boolean', async function() {
+      let rc;
+      const sql = 'SELECT ?';
+      const storeValue = true;
+      const expectedRetrievedValue = 1;
+
+      for await (const stmt of i(sqlite3.statements(db, sql))) {
+        // Comlink intercepts the 'bind' property so use an alias.
+        rc = await sqlite3.bind$(stmt, 1, storeValue);
+        expect(rc).toEqual(SQLite.SQLITE_OK);
+
+        while ((rc = await sqlite3.step(stmt)) !== SQLite.SQLITE_DONE) {
+          expect(rc).toEqual(SQLite.SQLITE_ROW);
+
+          expect(await sqlite3.column_count(stmt)).toEqual(1);
+          expect(await sqlite3.column_type(stmt, 0)).toEqual(SQLite.SQLITE_INTEGER);
+          expect(await sqlite3.column_int(stmt, 0)).toEqual(expectedRetrievedValue);
+        }
+      }
+    });
+
     it('should bind collection array', async function() {
       let rc;
       const sql = 'VALUES (?, ?, ?, ?, ?)';