@livestore/wa-sqlite 1.0.1-dev.2 → 1.0.1-dev.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/wa-sqlite",
-  "version": "1.0.1-dev.2",
+  "version": "1.0.1-dev.21",
   "type": "module",
   "main": "src/sqlite-api.js",
   "types": "src/types/index.d.ts",

package/src/sqlite-api.js

@@ -249,6 +249,58 @@ 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) {
+      verifyDatabase(db);
+      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);
+        return new Uint8Array(result.slice());
+      } else {
+        const size = Module.getValue(piSize, '*');
+        const result = Module.HEAPU8.subarray(address, address + size);
+        return result;
+      }
+    };
+  })();
+
+  // sqlite3.serialize = (function() {
+  //   const fname = 'sqlite3_serialize';
+  //   const f = Module.cwrap(fname, ...decl('nsnn:n'));
+  //   return function(db, schema, flags) {
+  //     verifyDatabase(db);
+  //     const piSize = tmpPtr[0];
+  //     const address = f(db, schema, piSize, flags);
+  //     const size = Module.getValue(piSize, '*');
+  //     const result = Module.HEAPU8.subarray(address, address + size);
+  //     return result;
+  //   };
+  // })();
+
+  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);
+    };
+  })();
+
   sqlite3.clear_bindings = (function() {
     const fname = 'sqlite3_clear_bindings';
     const f = Module.cwrap(fname, ...decl('n:n'));
@@ -445,7 +497,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);
+    for (const stmt of stmts) {
       let columns;
       while (sqlite3.step(stmt) === SQLite.SQLITE_ROW) {
         if (callback) {
@@ -455,6 +508,9 @@ export function Factory(Module) {
         }
       }
     }
+    for (const stmt of stmts) {
+      sqlite3.finalize(stmt);
+    }
     return SQLite.SQLITE_OK;
   };
 
@@ -510,6 +566,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);
+        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) {
@@ -532,6 +610,7 @@ export function Factory(Module) {
     };
   })();
 
+
   sqlite3.progress_handler = function(db, nProgressOps, handler, userData) {
     verifyDatabase(db);
     Module.progress_handler(db, nProgressOps, handler, userData);
@@ -689,10 +768,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);
 
@@ -754,16 +833,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() {
@@ -884,22 +963,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/index.d.ts

@@ -33,7 +33,7 @@ type SQLiteCompatibleType = number|string|Uint8Array|Array<number>|bigint|null;
  * @see https://sqlite.org/vfs.html
  * @see https://sqlite.org/c3ref/io_methods.html
  */
-declare interface SQLiteVFS {
+interface SQLiteVFS {
   /** Maximum length of a file path in UTF-8 bytes (default 64) */
   mxPathName?: number;
 
@@ -117,11 +117,11 @@ declare interface SQLiteVFS {
 }
 
 /**
- * Options object argument for {@link SQLiteAPI.statements}
+ * Options object argument for {@link SQLiteAPI['statements']}
  */
 declare interface SQLitePrepareOptions {
   /**
-   * Statement handles prepared and yielded by {@link SQLiteAPI.statements}
+   * Statement handles prepared and yielded by {@link SQLiteAPI['statements']}
    * are normally valid only within the scope of an iteration.
    * Set `unscoped` to `true` to give iterated statements an arbitrary
    * lifetime.
@@ -178,7 +178,7 @@ declare interface SQLitePrepareOptions {
  * 
  * @see https://sqlite.org/c3ref/funclist.html
  */
-declare interface SQLiteAPI {
+interface SQLiteAPI {
   /**
    * Bind a collection of values to a statement
    * 
@@ -341,7 +341,6 @@ declare interface SQLiteAPI {
    *   unsigned mFlags         Zero or more SQLITE_DESERIALIZE_* flags
    * );
    */
-
   deserialize(
     db: number,
     zSchema: string,
@@ -351,6 +350,51 @@ declare interface SQLiteAPI {
     mFlags: number
   ): number;
 
+  /**
+   * unsigned char *sqlite3_serialize(
+   *  sqlite3 *db,           The database connection
+   *  const char *zSchema,   Which DB to serialize. ex: "main", "temp", ...
+   *  sqlite3_int64 *piSize, Write size of the DB here, if not NULL
+   *  unsigned int mFlags    Zero or more SQLITE_SERIALIZE_* flags
+   * );
+   */
+  serialize(
+    db: number,
+    zSchema: string,
+    // mFlags: number
+  ): Uint8Array;
+
+  // sqlite3_backup *sqlite3_backup_init(
+  //   sqlite3 *pDest,                        /* Destination database handle */
+  //   const char *zDestName,                 /* Destination database name */
+  //   sqlite3 *pSource,                      /* Source database handle */
+  //   const char *zSourceName                /* Source database name */
+  // );
+  // int sqlite3_backup_step(sqlite3_backup *p, int nPage);
+  // int sqlite3_backup_finish(sqlite3_backup *p);
+  // int sqlite3_backup_remaining(sqlite3_backup *p);
+  // int sqlite3_backup_pagecount(sqlite3_backup *p);
+
+  backup_init(
+    pDest: number,
+    zDestName: string,
+    pSource: number,
+    zSourceName: string
+  ): number;
+
+  backup_step(p: number, nPage: number): number;
+  backup_finish(p: number): number;
+  backup_remaining(p: number): number;
+  backup_pagecount(p: number): number;
+
+  /**
+   * Combines the `backup_init`, `backup_step`, and `backup_finish` functions.
+   * destName/sourceName is usually "main" or "temp".
+   * 
+   * @returns `SQLITE_OK` (throws exception on error)
+   */
+  backup(pDest: number, zDestName: string, pSource: number, zSourceName: string): number;
+
   /**
    * Reset all bindings on a prepared statement.
    * @see https://www.sqlite.org/c3ref/clear_bindings.html
@@ -599,6 +643,12 @@ declare interface SQLiteAPI {
     zVfs?: string    
   ): Promise<number>;
 
+  open_v2Sync(
+    zFilename: string,
+    iFlags?: number,
+    zVfs?: string    
+  ): number;
+
   /**
    * Specify callback to be invoked between long-running queries
    * 
@@ -617,9 +667,9 @@ declare interface SQLiteAPI {
    * Reset a prepared statement object
    * @see https://www.sqlite.org/c3ref/reset.html
    * @param stmt prepared statement pointer
-   * @returns Promise-wrapped `SQLITE_OK` (rejects on error)
+   * @returns `SQLITE_OK` (rejects on error)
    */
-  reset(stmt: number): Promise<number>;
+  reset(stmt: number): number;
 
   /**
    * Convenience function to call `result_*` based of the type of `value`
@@ -746,7 +796,7 @@ declare interface SQLiteAPI {
    * @param options
    */
   // statements(db: number, sql: string, options?: SQLitePrepareOptions): AsyncIterable<number>;
-  statements(db: number, sql: string, options?: SQLitePrepareOptions): Iterable<number>;
+  statements(db: number, sql: string, options?: SQLitePrepareOptions): ReadonlyArray<number>;
 
   /**
    * Evaluate an SQL statement
@@ -843,6 +893,11 @@ declare interface SQLiteAPI {
   vfs_register(vfs: SQLiteVFS, makeDefault?: boolean): number;
 }
 
+declare module '@livestore/wa-sqlite' {
+  export type SQLiteAPI_ = SQLiteAPI;
+  export type SQLiteVFS_ = SQLiteVFS;
+}
+
 /** @ignore */
 declare module '@livestore/wa-sqlite/src/sqlite-constants.js' {
   export const SQLITE_OK: 0;
@@ -1115,6 +1170,7 @@ declare module '@livestore/wa-sqlite/src/VFS.js' {
   export * from '@livestore/wa-sqlite/src/sqlite-constants.js';
 
   export class Base {
+    name: string;
     mxPathName: number;
     /**
      * @param {number} fileId
@@ -1226,6 +1282,28 @@ declare module '@livestore/wa-sqlite/src/VFS.js' {
   }
 }
 
+/** @ignore */
+declare module '@livestore/wa-sqlite/src/FacadeVFS.js' {
+  export type FacadeVFS = any
+}
+  
+
+declare module '@livestore/wa-sqlite/src/examples/AccessHandlePoolVFS.js' {
+  import * as VFS from "@livestore/wa-sqlite/src/VFS.js";
+  export class AccessHandlePoolVFS extends VFS.Base {
+    constructor(name: string, module: any)
+    static create(name: string, module: any): Promise<AccessHandlePoolVFS>;
+  }
+}
+
+declare module '@livestore/wa-sqlite/src/examples/OPFSCoopSyncVFS.js' {
+  import * as VFS from "@livestore/wa-sqlite/src/VFS.js";
+  export class OPFSCoopSyncVFS extends VFS.Base {
+    constructor(name: string, module: any)
+    static create(name: string, module: any): Promise<OPFSCoopSyncVFS>;
+  }
+}
+
 /** @ignore */
 declare module '@livestore/wa-sqlite/src/examples/IndexedDbVFS.js' {
   import * as VFS from "@livestore/wa-sqlite/src/VFS.js";