@livestore/wa-sqlite 1.0.3-dev.6 → 1.0.5-dev.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/wa-sqlite",
-  "version": "1.0.3-dev.6",
+  "version": "1.0.5-dev.1",
   "type": "module",
   "main": "src/sqlite-api.js",
   "types": "src/types/index.d.ts",
@@ -15,12 +15,6 @@
     "dist/*",
     "test/*"
   ],
-  "scripts": {
-    "build-docs": "typedoc",
-    "start": "web-dev-server --node-resolve",
-    "test": "web-test-runner",
-    "test-manual": "web-test-runner --manual"
-  },
   "devDependencies": {
     "@types/jasmine": "^5.1.4",
     "@web/dev-server": "^0.4.6",
@@ -40,5 +34,11 @@
     "web-test-runner-jasmine@0.0.6": {
       "unplugged": true
     }
+  },
+  "scripts": {
+    "build-docs": "typedoc",
+    "start": "web-dev-server --node-resolve",
+    "test": "web-test-runner",
+    "test-manual": "web-test-runner --manual"
   }
-}
+}

package/src/WebLocksMixin.js

@@ -82,8 +82,10 @@ export const WebLocksMixin = superclass => class extends superclass {
    */
   async jUnlock(fileId, lockType) {
     try {
+      // SQLite can call xUnlock() without ever calling xLock() so
+      // the state may not exist.
       const lockState = this.#mapIdToState.get(fileId);
-      if (lockType >= lockState.type) return VFS.SQLITE_OK;
+      if (!(lockType < lockState?.type)) return VFS.SQLITE_OK;
   
       switch (this.#options.lockPolicy) {
         case 'exclusive':
@@ -122,17 +124,17 @@ export const WebLocksMixin = superclass => class extends superclass {
   }
 
   /**
-   * @param {number} pFile
+   * @param {number} fileId
    * @param {number} op
    * @param {DataView} pArg
    * @returns {number|Promise<number>}
    */
-  jFileControl(pFile, op, pArg) {
-    const lockState = this.#mapIdToState.get(pFile) ??
+  jFileControl(fileId, op, pArg) {
+    const lockState = this.#mapIdToState.get(fileId) ??
       (() => {
         // Call jLock() to create the lock state.
-        this.jLock(pFile, VFS.SQLITE_LOCK_NONE);
-        return this.#mapIdToState.get(pFile);
+        this.jLock(fileId, VFS.SQLITE_LOCK_NONE);
+        return this.#mapIdToState.get(fileId);
       })();
     if (op === WebLocksMixin.WRITE_HINT_OP_CODE &&
         this.#options.lockPolicy === 'shared+hint'){

package/src/examples/IDBMirrorVFS.js

@@ -332,14 +332,7 @@ export class IDBMirrorVFS extends FacadeVFS {
       const file = this.#mapIdToFile.get(fileId);
 
       if (file.flags & VFS.SQLITE_OPEN_MAIN_DB) {
-        if (!file.txActive) {
-          file.txActive = {
-            path: file.path,
-            txId: file.viewTx.txId + 1,
-            blocks: new Map(),
-            fileSize: file.blockSize * file.blocks.size,
-          };
-        }
+        this.#requireTxActive(file);
         file.txActive.blocks.set(iOffset, pData.slice());
         file.txActive.fileSize = Math.max(file.txActive.fileSize, iOffset + pData.byteLength);
         file.blockSize = pData.byteLength;
@@ -375,6 +368,7 @@ export class IDBMirrorVFS extends FacadeVFS {
       const file = this.#mapIdToFile.get(fileId);
 
       if (file.flags & VFS.SQLITE_OPEN_MAIN_DB) {
+        this.#requireTxActive(file);
         file.txActive.fileSize = iSize;
       } else {
         // All files that are not main databases are stored in a single
@@ -717,6 +711,20 @@ export class IDBMirrorVFS extends FacadeVFS {
     file.txWriteHint = false;
   }
 
+  /**
+   * @param {File} file 
+   */
+  #requireTxActive(file) {
+    if (!file.txActive) {
+      file.txActive = {
+        path: file.path,
+        txId: file.viewTx.txId + 1,
+        blocks: new Map(),
+        fileSize: file.blockSize * file.blocks.size,
+      };
+    }
+  }
+
   /**
    * @param {string} path 
    * @returns {Promise}

package/src/examples/OPFSAdaptiveVFS.js

@@ -413,7 +413,7 @@ export class OPFSAdaptiveVFS extends WebLocksMixin(FacadeVFS) {
       this.lastError = e;
       return VFS.SQLITE_IOERR;
     }
-    return VFS.SQLITE_NOTFOUND;
+    return super.jFileControl(fileId, op, pArg);
   }
 
   jGetLastError(zBuf) {

package/src/examples/OPFSPermutedVFS.js

@@ -463,6 +463,9 @@ export class OPFSPermutedVFS extends FacadeVFS {
       const file = this.#mapIdToFile.get(fileId);
       if ((file.flags & VFS.SQLITE_OPEN_MAIN_DB) && !file.txIsOverwrite) {
         file.abortController.signal.throwIfAborted();
+        if (!file.txActive) {
+          this.#beginTx(file);
+        }
         file.txActive.fileSize = iSize;
 
         // Remove now obsolete pages from file.txActive.pages

package/src/examples/README.md

@@ -19,7 +19,7 @@ Changing the page size after the database is created is not supported (this is a
 ### IDBMirrorVFS
 This VFS keeps all files in memory, persisting database files to IndexedDB. It works on all contexts.
 
-IDBBatchAtomicVFS can trade durability for performance by setting `PRAGMA synchronous=normal`.
+IDBMirrorVFS can trade durability for performance by setting `PRAGMA synchronous=normal`.
 
 Changing the page size after the database is created is not supported.
 

package/src/sqlite-api.js

@@ -499,6 +499,7 @@ export function Factory(Module) {
           columns = columns ?? sqlite3.column_names(stmt);
           const row = sqlite3.row(stmt);
           callback(row, columns);
+          callback(row, columns);
         }
       }
     }
@@ -764,6 +765,7 @@ export function Factory(Module) {
 
       const stmts = [];
 
+      // return (async function*() {
       const onFinally = [];
       // try {
         // Encode SQL string to UTF-8.
@@ -802,15 +804,6 @@ export function Factory(Module) {
           // Call sqlite3_prepare_v3() for the next statement.
           // Allow retry operations.
           const zTail = Module.getValue(pzTail, '*');
-          // const rc = await retry(() => {
-          //   return prepare(
-          //     db,
-          //     zTail,
-          //     pzEnd - pzTail,
-          //     options.flags || 0,
-          //     pStmt,
-          //     pzTail);
-          // });
           const rc = prepare(
             db,
             zTail,
@@ -854,6 +847,11 @@ export function Factory(Module) {
     };
   })();
 
+  sqlite3.commit_hook = function(db, xCommitHook) {
+    verifyDatabase(db);
+    Module.commit_hook(db, xCommitHook);
+  };
+
   sqlite3.update_hook = function(db, xUpdateHook) {
     verifyDatabase(db);
 
@@ -1048,12 +1046,19 @@ export function Factory(Module) {
       const changesetOutPtr = Module.getValue(outPtrPtr, 'i32');
 
       // Copy the inverted changeset data
-      const changesetOut = new Uint8Array(Module.HEAPU8.buffer, changesetOutPtr, outLength);
+      const changesetOut = new Uint8Array(Module.HEAPU8.buffer, changesetOutPtr, outLength).slice();
 
       // Free allocated memory
       Module._sqlite3_free(inPtr);
-      Module._sqlite3_free(outLengthPtr);
-      Module._sqlite3_free(outPtrPtr);
+
+      // TODO investigate why freeing these pointers causes a crash
+      // RuntimeError: Out of bounds memory access (evaluating 'Module._sqlite3_free(outLengthPtr)')
+      // Repro: https://gist.github.com/schickling/08b10b6fda8583601e586cb0bea333ce
+
+      // Module._sqlite3_free(outLengthPtr);
+      // Module._sqlite3_free(outPtrPtr);
+
+      Module._sqlite3_free(changesetOutPtr);
 
       return changesetOut;
     };

package/src/types/index.d.ts

@@ -525,6 +525,19 @@ interface SQLiteAPI {
    */
   column_type(stmt: number, i: number): number;
 
+  /**
+   * Register a commit hook
+   * 
+   * @see https://www.sqlite.org/c3ref/commit_hook.html
+   *
+   * @param db database pointer
+   * @param callback If a non-zero value is returned, commit is converted into
+   * a rollback; disables callback when null
+   */
+  commit_hook(
+    db: number,
+    callback: (() => number) | null): void;
+
   /**
    * Create or redefine SQL functions
    * 

package/test/callbacks.test.js

@@ -422,4 +422,160 @@ for (const [key, factory] of FACTORIES) {
       expect(calls).toEqual([[23, "main", "t", 1n]]);
     });
   });
+
+  describe(`${key} commit_hook`, function() {
+    let db;
+    beforeEach(async function() {
+      db = await sqlite3.open_v2(':memory:');
+    });
+  
+    afterEach(async function() {
+      await sqlite3.close(db);
+    });
+
+    it('should call commit hook', async function() {
+      let rc;
+
+      let callsCount = 0;
+      const resetCallsCount = () => callsCount = 0;
+
+      sqlite3.commit_hook(db, () => {
+        callsCount++;
+        return 0;
+      });
+      expect(callsCount).toEqual(0);
+      resetCallsCount();
+
+      rc = await sqlite3.exec(db, `
+        CREATE TABLE t(i integer primary key, x);
+      `);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+      expect(callsCount).toEqual(1);
+      resetCallsCount();
+
+      rc = await sqlite3.exec(db, `
+        SELECT * FROM t;
+      `);
+      expect(callsCount).toEqual(0);
+      resetCallsCount();
+
+      rc = await sqlite3.exec(db, `
+        BEGIN TRANSACTION;
+        INSERT INTO t VALUES (1, 'foo');
+        ROLLBACK;
+      `);
+      expect(callsCount).toEqual(0);
+      resetCallsCount();
+
+      rc = await sqlite3.exec(db, `
+        BEGIN TRANSACTION;
+        INSERT INTO t VALUES (1, 'foo');
+        INSERT INTO t VALUES (2, 'bar');
+        COMMIT;
+      `);
+      expect(callsCount).toEqual(1);
+      resetCallsCount();
+    });
+
+    it('can change commit hook', async function() {
+      let rc;
+      rc = await sqlite3.exec(db, `
+        CREATE TABLE t(i integer primary key, x);
+      `);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+
+      let a = 0;
+      let b = 0;
+
+      // set hook to increment `a` on commit
+      sqlite3.commit_hook(db, () => {
+        a++;
+        return 0;
+      });
+      rc = await sqlite3.exec(db, `
+        INSERT INTO t VALUES (1, 'foo');
+      `);
+      expect(a).toEqual(1);
+      expect(b).toEqual(0);
+
+      // switch to increment `b`
+      sqlite3.commit_hook(db, () => {
+        b++;
+        return 0;
+      });
+
+      rc = await sqlite3.exec(db, `
+        INSERT INTO t VALUES (2, 'bar');
+      `);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+      expect(a).toEqual(1);
+      expect(b).toEqual(1);
+
+      // disable hook by passing null
+      sqlite3.commit_hook(db, null);
+
+      rc = await sqlite3.exec(db, `
+        INSERT INTO t VALUES (3, 'qux');
+      `);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+      expect(a).toEqual(1);
+      expect(b).toEqual(1);
+    });
+
+    it('can rollback based on return value', async function() {
+      let rc;
+      rc = await sqlite3.exec(db, `
+        CREATE TABLE t(i integer primary key, x);
+      `);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+
+      // accept commit by returning 0
+      sqlite3.commit_hook(db, () => 0);
+      rc = await sqlite3.exec(db, `
+        INSERT INTO t VALUES (1, 'foo');
+      `);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+
+      // reject commit by returning 1, causing rollback
+      sqlite3.commit_hook(db, () => 1);
+      await expectAsync(
+        sqlite3.exec(db, `INSERT INTO t VALUES (2, 'bar');`)
+      ).toBeRejected();
+
+      // double-check that the insert was rolled back
+      let hasRow = false;
+      rc = await sqlite3.exec(db, `
+        SELECT * FROM t WHERE i = 2;
+      `, () => hasRow = true);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+      expect(hasRow).toBeFalse();
+    });
+
+    it('does not overwrite update_hook', async function() {
+      let rc;
+      rc = await sqlite3.exec(db, `
+        CREATE TABLE t(i integer primary key, x);
+      `);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+
+      let updateHookInvocationsCount = 0;
+      sqlite3.update_hook(db, (...args) => {
+        updateHookInvocationsCount++;
+      });
+
+      let commitHookInvocationsCount = 0;
+      sqlite3.commit_hook(db, () => {
+        commitHookInvocationsCount++;
+        return 0;
+      });
+
+      rc = await sqlite3.exec(db, `
+        INSERT INTO t VALUES (1, 'foo');
+      `);
+      expect(rc).toEqual(SQLite.SQLITE_OK);
+
+      expect(updateHookInvocationsCount).toEqual(1);
+      expect(commitHookInvocationsCount).toEqual(1);
+    });
+  });
 }