@livestore/wa-sqlite 1.0.1-dev.9 → 1.0.3-dev.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/wa-sqlite",
-  "version": "1.0.1-dev.9",
+  "version": "1.0.3-dev.3",
   "type": "module",
   "main": "src/sqlite-api.js",
   "types": "src/types/index.d.ts",
@@ -40,6 +40,5 @@
     "web-test-runner-jasmine@0.0.6": {
       "unplugged": true
     }
-  },
-  "packageManager": "yarn@4.0.2"
-}
+  }
+}

package/src/sqlite-api.js

@@ -249,16 +249,46 @@ export function Factory(Module) {
     };
   })();
 
+  const SQLITE_SERIALIZE_NOCOPY = 0x0_01
+
   sqlite3.serialize = (function() {
     const fname = 'sqlite3_serialize';
     const f = Module.cwrap(fname, ...decl('nsnn:n'));
-    return function(db, schema, piSize, flags) {
+    return function(db, schema) {
       verifyDatabase(db);
-      // TODO alloc + free memory for result?
-      const address = f(db, schema, piSize, flags);
-      const result = Module.HEAPU8.subarray(address, address + piSize);
+      const piSize = tmpPtr[0];
+      let address = f(db, schema, piSize, 0);
+      if (address === 0) {
+        address = f(db, schema, piSize, SQLITE_SERIALIZE_NOCOPY);
+        const size = Module.getValue(piSize, '*');
+        const result = Module.HEAPU8.subarray(address, address + size);
+        // NOTE Given that the memory is owned by SQLite, we must copy it.
+        return new Uint8Array(result.slice());
+      } else {
+        const size = Module.getValue(piSize, '*');
+        const result = Module.HEAPU8.subarray(address, address + size);
+        // Here we're getting a copy of the memory, so we can return it directly.
+        return new Uint8Array(result);
+      }
+    };
+  })();
 
-      return result;
+  // https://www.sqlite.org/c3ref/backup_finish.html
+  // https://www.sqlite.org/backup.html
+  sqlite3.backup = (function() {
+    const fInit = Module.cwrap('sqlite3_backup_init', ...decl('nsns:n'));
+    const fStep = Module.cwrap('sqlite3_backup_step', ...decl('nn:n'));
+    const fFinish = Module.cwrap('sqlite3_backup_finish', ...decl('n:n'));
+    return function(dest, destName, source, sourceName) {
+      verifyDatabase(dest);
+      verifyDatabase(source);
+      const backup = fInit(dest, destName, source, sourceName);
+      if (backup === 0) {
+        const errMsg = Module.ccall('sqlite3_errmsg', 'string', ['number'], [dest]);
+        throw new SQLiteError(`backup failed: ${errMsg}`, SQLite.SQLITE_ERROR);
+      }
+      fStep(backup, -1);
+      return fFinish(backup);
     };
   })();
 
@@ -458,7 +488,8 @@ export function Factory(Module) {
   //   return SQLite.SQLITE_OK;
   // };
   sqlite3.exec = function(db, sql, callback) {
-    for (const stmt of sqlite3.statements(db, sql)) {
+    const stmts = sqlite3.statements(db, sql, { unscoped: true });
+    for (const stmt of stmts) {
       let columns;
       while (sqlite3.step(stmt) === SQLite.SQLITE_ROW) {
         if (callback) {
@@ -468,6 +499,9 @@ export function Factory(Module) {
         }
       }
     }
+    for (const stmt of stmts) {
+      sqlite3.finalize(stmt);
+    }
     return SQLite.SQLITE_OK;
   };
 
@@ -523,6 +557,28 @@ export function Factory(Module) {
   })();
 
   sqlite3.open_v2 = (function() {
+    const fname = 'sqlite3_open_v2';
+    const f = Module.cwrap(fname, ...decl('snnn:n'), { async });
+    return async function(zFilename, flags, zVfs) {
+      flags = flags || SQLite.SQLITE_OPEN_CREATE | SQLite.SQLITE_OPEN_READWRITE;
+      zVfs = createUTF8(zVfs);
+      try {
+        // Allow retry operations.
+        const rc = await retry(() => f(zFilename, tmpPtr[0], flags, zVfs));
+
+        const db = Module.getValue(tmpPtr[0], '*');
+        databases.add(db);
+
+        Module.ccall('RegisterExtensionFunctions', 'void', ['number'], [db]);
+        check(fname, rc, db);
+        return db;
+      } finally {
+        Module._sqlite3_free(zVfs);
+      }
+    };
+  })();
+
+  sqlite3.open_v2Sync = (function() {
     const fname = 'sqlite3_open_v2';
     const f = Module.cwrap(fname, ...decl('snnn:n'), { async });
     return function(zFilename, flags, zVfs) {
@@ -537,7 +593,7 @@ export function Factory(Module) {
         databases.add(db);
 
         Module.ccall('RegisterExtensionFunctions', 'void', ['number'], [db]);
-        check(fname, rc);
+        check(fname, rc, db);
         return db;
       } finally {
         Module._sqlite3_free(zVfs);
@@ -545,6 +601,7 @@ export function Factory(Module) {
     };
   })();
 
+
   sqlite3.progress_handler = function(db, nProgressOps, handler, userData) {
     verifyDatabase(db);
     Module.progress_handler(db, nProgressOps, handler, userData);
@@ -675,9 +732,9 @@ export function Factory(Module) {
     };
     function adapt(f) {
       // return f instanceof AsyncFunction ?
-      //   (async (_, iAction, p3, p4, p5, p6) => f(cvtArgs(_, iAction, p3, p4, p5, p6))) :
-      //   ((_, iAction, p3, p4, p5, p6) => f(cvtArgs(_, iAction, p3, p4, p5, p6)));
-      return ((_, iAction, p3, p4, p5, p6) => f(cvtArgs(_, iAction, p3, p4, p5, p6)));
+      //   (async (_, iAction, p3, p4, p5, p6) => f(...cvtArgs(_, iAction, p3, p4, p5, p6))) :
+      //   ((_, iAction, p3, p4, p5, p6) => f(...cvtArgs(_, iAction, p3, p4, p5, p6)));
+      return ((_, iAction, p3, p4, p5, p6) => f(...cvtArgs(_, iAction, p3, p4, p5, p6)));
     }
 
     const result = Module.set_authorizer(db, adapt(xAuth), pApp);
@@ -702,10 +759,10 @@ export function Factory(Module) {
       // { async: true });
       { async: false });
 
-      const results = [];
+      const stmts = [];
 
       const onFinally = [];
-      try {
+      // try {
         // Encode SQL string to UTF-8.
         const utf8 = new TextEncoder().encode(sql);
 
@@ -767,16 +824,16 @@ export function Factory(Module) {
           if (stmt) {
             mapStmtToDB.set(stmt, db);
             // yield stmt;
-            results.push(stmt);
+            stmts.push(stmt);
           }
         } while (stmt);
-      } finally {
-        while (onFinally.length) {
-          onFinally.pop()();
-        }
-      }
+      // } finally {
+      //   while (onFinally.length) {
+      //     onFinally.pop()();
+      //   }
+      // }
 
-      return results;
+      return stmts;
   };
 
   sqlite3.step = (function() {
@@ -794,6 +851,318 @@ export function Factory(Module) {
     };
   })();
 
+  sqlite3.update_hook = function(db, xUpdateHook) {
+    verifyDatabase(db);
+
+    // Convert SQLite callback arguments to JavaScript-friendly arguments.
+    function cvtArgs(iUpdateType, dbName, tblName, lo32, hi32) {
+      return [
+        iUpdateType,
+        Module.UTF8ToString(dbName),
+        Module.UTF8ToString(tblName),
+		cvt32x2ToBigInt(lo32, hi32)
+      ];
+    };
+    function adapt(f) {
+      // return f instanceof AsyncFunction ?
+      //   (async (iUpdateType, dbName, tblName, lo32, hi32) => f(...cvtArgs(iUpdateType, dbName, tblName, lo32, hi32))) :
+      //   ((iUpdateType, dbName, tblName, lo32, hi32) => f(...cvtArgs(iUpdateType, dbName, tblName, lo32, hi32)));
+      return ((iUpdateType, dbName, tblName, lo32, hi32) => f(...cvtArgs(iUpdateType, dbName, tblName, lo32, hi32)));
+    }
+
+    Module.update_hook(db, adapt(xUpdateHook));
+  };;
+
+  // Session extension bindings
+  sqlite3.session_create = (function() {
+    const fname = 'sqlite3session_create';
+    const f = Module.cwrap(fname, ...decl('nsn:n'));
+    return function(db, zDb) {
+      verifyDatabase(db);
+      const ppSession = Module._malloc(4);
+      const result = f(db, zDb, ppSession);
+
+      if (result !== SQLite.SQLITE_OK) {
+        check(fname, result, db);
+      }
+
+      const pSession = Module.getValue(ppSession, 'i32');
+      return pSession;
+    };
+  })();
+
+  sqlite3.session_attach = (function() {
+    const fname = 'sqlite3session_attach';
+    const f = Module.cwrap(fname, ...decl('ns:n'));
+    return function(pSession, zTab) {
+      if (typeof pSession !== 'number') {
+        throw new SQLiteError('Invalid session object', SQLite.SQLITE_MISUSE);
+      }
+      const result = f(pSession, zTab);
+      return check(fname, result);
+    };
+  })();
+
+  sqlite3.session_enable = (function() {
+    const fname = 'sqlite3session_enable';
+    const f = Module.cwrap(fname, ...decl('nn:n'));
+    return function(pSession, enableBool) {
+      const enable = enableBool ? 1 : 0;
+      if (typeof pSession !== 'number') {
+        throw new SQLiteError('Invalid session object', SQLite.SQLITE_MISUSE);
+      }
+      const result = f(pSession, enable);
+      if (result !== enable) {
+        throw new SQLiteError('Failed to enable session', SQLite.SQLITE_MISUSE);
+      }
+    };
+  })();
+
+  sqlite3.session_changeset = (function() {
+    const fname = 'sqlite3session_changeset';
+    const f = Module.cwrap(fname, ...decl('nnn:n'));
+    return function(pSession) {
+      if (typeof pSession !== 'number') {
+        throw new SQLiteError('Invalid session object', SQLite.SQLITE_MISUSE);
+      }
+      
+      // Allocate memory for the size (int) and the changeset pointer (void*)
+      const sizePtr = Module._malloc(4);
+      const changesetPtrPtr = Module._malloc(4);
+      
+      try {
+        const result = f(pSession, sizePtr, changesetPtrPtr);
+        if (result === SQLite.SQLITE_OK) {
+          // Get the size of the changeset
+          const size = Module.getValue(sizePtr, 'i32');
+          // Get the pointer to the changeset
+          const changesetPtr = Module.getValue(changesetPtrPtr, 'i32');
+          
+          // Ensure the pointer is valid before accessing memory
+          if (changesetPtr === 0) {
+            throw new SQLiteError('Failed to retrieve changeset pointer', SQLite.SQLITE_ERROR);
+          }
+
+          // Copy the changeset data
+          const changeset = new Uint8Array(Module.HEAPU8.subarray(changesetPtr, changesetPtr + size));
+
+          // Free the allocated changeset memory
+          Module._sqlite3_free(changesetPtr);
+          
+          // Return a copy of the changeset
+          return {
+            result: result,
+            size: size,
+            changeset: changeset
+          };
+        }
+        return check(fname, result);
+      } finally {
+        // Free the allocated memory
+        Module._free(sizePtr);
+        Module._free(changesetPtrPtr);
+      }
+    };
+  })();
+
+  sqlite3.session_delete = (function() {
+    const fname = 'sqlite3session_delete';
+    const f = Module.cwrap(fname, ...decl('n:v'));
+    return function(pSession) {
+      if (typeof pSession !== 'number') {
+        throw new SQLiteError('Invalid session object', SQLite.SQLITE_MISUSE);
+      }
+      const result = f(pSession);
+      return result;
+    };
+  })();
+
+  sqlite3.changeset_start = (function() {
+    const fname = 'sqlite3changeset_start';
+    const f = Module.cwrap(fname, ...decl('nnn:n'));
+    return function(changesetData) {
+      // Allocate memory for the input changeset data
+      const inPtr = Module._sqlite3_malloc(changesetData.length);
+      Module.HEAPU8.subarray(inPtr).set(changesetData);
+
+      // Allocate memory for the changeset iterator pointer
+      const ppIter = Module._malloc(4);
+
+      try {
+        // Call the wrapped C function
+        const result = f(ppIter, changesetData.length, inPtr);
+
+        if (result !== SQLite.SQLITE_OK) {
+          check(fname, result); // Handle errors appropriately
+        }
+
+        // Retrieve the changeset iterator handle
+        const pIter = Module.getValue(ppIter, 'i32');
+
+        return pIter;
+      } finally {
+        // Free allocated memory
+        Module._sqlite3_free(inPtr);
+        Module._free(ppIter);
+      }
+    };
+  })();
+
+  sqlite3.changeset_finalize = (function() {
+    const fname = 'sqlite3changeset_finalize';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(pIter) {
+      const result = f(pIter);
+      return result;
+    };
+  })();
+
+  sqlite3.changeset_invert = (function() {
+    const fname = 'sqlite3changeset_invert';
+    const f = Module.cwrap(fname, ...decl('nn:nn'));
+    return function(changesetData) {
+      // Allocate memory for the input changeset data
+      const inPtr = Module._sqlite3_malloc(changesetData.length);
+      Module.HEAPU8.subarray(inPtr).set(changesetData);
+
+      // Allocate memory for the output changeset length and pointer
+      const outLengthPtr = Module._malloc(4);
+      const outPtrPtr = Module._malloc(4);
+
+      // Call the wrapped C function
+      const result = f(changesetData.length, inPtr, outLengthPtr, outPtrPtr);
+
+      if (result !== SQLite.SQLITE_OK) {
+        check(fname, result); // Handle errors appropriately
+      }
+
+      // Retrieve the size and pointer of the inverted changeset
+      const outLength = Module.getValue(outLengthPtr, 'i32');
+      const changesetOutPtr = Module.getValue(outPtrPtr, 'i32');
+
+      // Copy the inverted changeset data
+      const changesetOut = new Uint8Array(Module.HEAPU8.buffer, changesetOutPtr, outLength);
+
+      // Free allocated memory
+      Module._sqlite3_free(inPtr);
+      Module._sqlite3_free(outLengthPtr);
+      Module._sqlite3_free(outPtrPtr);
+
+      return changesetOut;
+    };
+  })();
+
+  /** 
+   * Convenience function to get an inverted changeset from a session
+   * without having to call sqlite3session_changeset() and then sqlite3changeset_invert().
+   * It's more efficient as it's reusing the same memory allocation for the changeset.
+   */
+  sqlite3.session_changeset_inverted = (function() {
+    const fnameChangeset = 'sqlite3session_changeset';
+    const fChangeset = Module.cwrap(fnameChangeset, ...decl('nnn:n'));
+    const fnameInvert = 'sqlite3changeset_invert';
+    const fInvert = Module.cwrap(fnameInvert, ...decl('nn:nn'));
+    return function(pSession) {
+      if (typeof pSession !== 'number') {
+        throw new SQLiteError('Invalid session object', SQLite.SQLITE_MISUSE);
+      }
+
+      // Allocate memory for the size (int) and the changeset pointer (void*)
+      const sizePtr = Module._malloc(4);
+      const changesetPtrPtr = Module._malloc(4);
+
+      // Allocate memory for the size (int) and the inverted changeset pointer (void*)
+      const sizePtrInvert = Module._malloc(4);
+      const changesetPtrPtrInvert = Module._malloc(4);
+      
+      try {
+        const changesetResult = fChangeset(pSession, sizePtr, changesetPtrPtr);
+        if (changesetResult !== SQLite.SQLITE_OK) {
+          return check(fnameChangeset, changesetResult);
+        }
+
+        // Get the size of the changeset
+        const size = Module.getValue(sizePtr, 'i32');
+        // Get the pointer to the changeset
+        const changesetPtr = Module.getValue(changesetPtrPtr, 'i32');
+
+        
+        const invertedResult = fInvert(size, changesetPtr, sizePtrInvert, changesetPtrPtrInvert);
+        
+        if (invertedResult !== SQLite.SQLITE_OK) {
+          return check(fnameInvert, invertedResult);
+        }
+
+        // Get the size of the changeset
+        const sizeInvert = Module.getValue(sizePtrInvert, 'i32');
+        // Get the pointer to the changeset
+        const changesetPtrInvert = Module.getValue(changesetPtrPtrInvert, 'i32');
+        
+        // Copy the changeset data
+        const changesetInvert = new Uint8Array(Module.HEAPU8.buffer, changesetPtrInvert, sizeInvert);
+
+        Module._sqlite3_free(changesetPtr);
+        Module._sqlite3_free(changesetPtrInvert)
+
+        // Return a copy of the changeset
+        return {
+          result: changesetResult,
+          size: size,
+          changeset: new Uint8Array(changesetInvert)
+        };
+      } finally {
+        // Free the allocated memory
+        Module._free(sizePtr);
+        Module._free(changesetPtrPtr);
+        Module._free(sizePtrInvert);
+        Module._free(changesetPtrPtrInvert);
+      }
+
+    };
+  })();
+
+  sqlite3.changeset_apply = (function() {
+    const fname = 'sqlite3changeset_apply';
+    const f = Module.cwrap(fname, ...decl('nnnnnn:n'));
+    return function(db, changesetData, options) {
+      /*
+        int sqlite3changeset_apply(
+          sqlite3 *db,                    Apply change to "main" db of this handle
+          int nChangeset,                 Size of changeset in bytes 
+          void *pChangeset,               Changeset blob
+          int(*xFilter)(
+            void *pCtx,                   Copy of sixth arg to _apply() 
+            const char *zTab              Table name 
+          ),
+          int(*xConflict)(
+            void *pCtx,                   Copy of sixth arg to _apply() 
+            int eConflict,                DATA, MISSING, CONFLICT, CONSTRAINT 
+            sqlite3_changeset_iter *p     Handle describing change and conflict
+          ),
+          void *pCtx                      First argument passed to xConflict
+        );
+      */
+      const inPtr = Module._sqlite3_malloc(changesetData.length);
+      Module.HEAPU8.subarray(inPtr).set(changesetData);
+
+      // https://sqlite.org/session/c_changeset_abort.html
+      const SQLITE_CHANGESET_REPLACE = 1
+      const onConflict = () => {
+        return SQLITE_CHANGESET_REPLACE;
+      }
+
+      const result = f(db, changesetData.length, inPtr, null, onConflict, null);
+
+      if (result !== SQLite.SQLITE_OK) {
+        check(fname, result);
+      }
+
+      return result;
+    }
+  })();
+
+  // Session extension bindings end
+
   sqlite3.value = function(pValue) {
     const type = sqlite3.value_type(pValue);
     switch (type) {
@@ -881,11 +1250,18 @@ export function Factory(Module) {
     };
   })();
 
+  const registeredVfs = new Set();
+
   sqlite3.vfs_register = function(vfs, makeDefault) {
+    if (registeredVfs.has(vfs.name)) return
     const result = Module.vfs_register(vfs, makeDefault);
-    return check('sqlite3_vfs_register', result);
+    const res = check('sqlite3_vfs_register', result);
+    registeredVfs.add(vfs.name);
+    return res
   };
 
+  sqlite3.vfs_registered = registeredVfs;
+
   function check(fname, result, db = null, allowed = [SQLite.SQLITE_OK]) {
     if (allowed.includes(result)) return result;
     const message = db ?
@@ -897,22 +1273,22 @@ export function Factory(Module) {
   // This function is used to automatically retry failed calls that
   // have pending retry operations that should allow the retry to
   // succeed.
-  // async function retry(f) {
-  //   let rc;
-  //   do {
-  //     // Wait for all pending retry operations to complete. This is
-  //     // normally empty on the first loop iteration.
-  //     if (Module.retryOps.length) {
-  //       await Promise.all(Module.retryOps);
-  //       Module.retryOps = [];
-  //     }
+  async function retry(f) {
+    let rc;
+    do {
+      // Wait for all pending retry operations to complete. This is
+      // normally empty on the first loop iteration.
+      if (Module.retryOps.length) {
+        await Promise.all(Module.retryOps);
+        Module.retryOps = [];
+      }
       
-  //     rc = await f();
+      rc = await f();
 
-  //     // Retry on failure with new pending retry operations.
-  //   } while (rc && Module.retryOps.length);
-  //   return rc;
-  // }
+      // Retry on failure with new pending retry operations.
+    } while (rc && Module.retryOps.length);
+    return rc;
+  }
 
   return sqlite3;
 }

package/src/types/globals.d.ts

@@ -1,6 +1,6 @@
-// declare namespace Asyncify {
-//   function handleAsync(f: () => Promise<any>);
-// }
+declare namespace Asyncify {
+  function handleAsync(f: () => Promise<any>);
+}
 
 declare function UTF8ToString(ptr: number): string;
 declare function lengthBytesUTF8(s: string): number;