allow modular usage of VFS:

* add 'createWasmInitializer' function - creating a function akin to 'initWasm' with custom setup (WASM ModuleFactory, vfsFactory)
* keep the default 'initWasm' (Asyncify build, IDBBatchAtomic) for API consistency
* add (optional) parameter for 'initializer' in browserdb, react and direct-connect-browser packages

Author: ikusteu

packages/crsqlite-wasm/src/index.ts

@@ -12,17 +12,19 @@ type SQLiteAPI = ReturnType<typeof SQLite.Factory>;
 export class SQLite3 {
   constructor(private base: SQLiteAPI) {}
 
-  open(filename?: string, mode: string = "c") {
+  open(filename: string = ":memory:", mode: string = "c", vfs_name?: string) {
     return serialize(
       null,
       undefined,
       () => {
         return this.base.open_v2(
-          filename || ":memory:",
+          filename,
           SQLite.SQLITE_OPEN_CREATE |
             SQLite.SQLITE_OPEN_READWRITE |
             SQLite.SQLITE_OPEN_URI,
-          filename != null ? "idb-batch-atomic" : undefined
+          // My understanding is that filename = ":memory:" case doesn't care about the vfs_name, whereas not specifying
+          // the vfs_name will use the default vfs (which is the desired VFS if set up using 'iniwWasm')
+          vfs_name
         );
       },
       topLevelMutex
@@ -47,14 +49,28 @@ export class SQLite3 {
   }
 }
 
-export default async function initWasm(
+export type VFSFactory = (module: SQLiteAPI) => Promise<SQLiteVFS>;
+export type ModuleFactory = (moduleArg?: Record<string, any>) => any;
+
+export type WasmInitializerConfig = {
+  ModuleFactory: ModuleFactory;
+  vfsFactory: VFSFactory;
+};
+
+export type WasmInitializer = (
+  locateWasm?: (file: string) => string
+) => Promise<SQLite3>;
+
+async function initWasmInternal(
+  ModuleFactory: ModuleFactory,
+  vfsFactory: VFSFactory,
   locateWasm?: (file: string) => string
 ): Promise<SQLite3> {
   if (api != null) {
     return api;
   }
 
-  const wasmModule = await SQLiteAsyncESMFactory({
+  const wasmModule = await ModuleFactory({
     locateFile(file: string) {
       if (locateWasm) {
         return locateWasm(file);
@@ -63,9 +79,37 @@ export default async function initWasm(
     },
   });
   const sqlite3 = SQLite.Factory(wasmModule);
-  const vfs = await IDBBatchAtomicVFS.create("idb-batch-atomic", wasmModule);
+  const vfs = await vfsFactory(wasmModule);
   sqlite3.vfs_register(vfs, true);
 
   api = new SQLite3(sqlite3);
   return api;
 }
+
+/**
+ * Default initializer (for backwards compatibility), uses:
+ * - asyncify WASM build
+ * - IDB Batch Atomic VFS
+ */
+export default async function initWasm(
+  locateWasm?: (file: string) => string
+): Promise<SQLite3> {
+  const ModuleFactory = SQLiteAsyncESMFactory;
+  const vfsFactory: VFSFactory = (module) =>
+    IDBBatchAtomicVFS.create("idb-batch-atomic", module);
+  return initWasmInternal(ModuleFactory, vfsFactory, locateWasm);
+}
+
+/**
+ * Creates a custom wasm initializer (same signature as default `initWasm`) allowing
+ * consumer to provide:
+ * - custom WASM glue factory
+ * - custom VFS implementation.
+ */
+export function createWasmInitializer({
+  ModuleFactory,
+  vfsFactory,
+}: WasmInitializerConfig): WasmInitializer {
+  return (locateWasm?: (file: string) => string) =>
+    initWasmInternal(ModuleFactory, vfsFactory, locateWasm);
+}

packages/direct-connect-browser/src/common/DB.ts

@@ -1,4 +1,4 @@
-import initWasm from "@vlcn.io/crsqlite-wasm";
+import initWasm, { WasmInitializer } from "@vlcn.io/crsqlite-wasm";
 import { DBAsync, StmtAsync } from "@vlcn.io/xplat-api";
 import { TXAsync } from "@vlcn.io/xplat-api";
 import { DBID } from "@vlcn.io/xplat-api";
@@ -100,8 +100,12 @@ export class DB {
   }
 }
 
-export default async function getDB(wasmUri: string | undefined, dbid: DBID) {
-  const sqlite = await initWasm(wasmUri ? () => wasmUri : undefined);
+export default async function getDB(
+  wasmUri: string | undefined,
+  dbid: DBID,
+  initializer: WasmInitializer = initWasm
+) {
+  const sqlite = await initializer(wasmUri ? () => wasmUri : undefined);
   const db = await sqlite.open(dbid);
 
   const [pullChangesetStmt, applyChangesetStmt, updatePeerTrackerStmt] =

packages/react/src/db/DBFactory.ts

@@ -1,4 +1,4 @@
-import initWasm, { SQLite3 } from "@vlcn.io/crsqlite-wasm";
+import initWasm, { SQLite3, WasmInitializer } from "@vlcn.io/crsqlite-wasm";
 import tblrx from "@vlcn.io/rx-tbl";
 import { CtxAsync } from "../context.js";
 import { Mutex } from "async-mutex";
@@ -14,12 +14,12 @@ const dbMap = new Map<DBID, [string, CtxAsync]>();
 const hooks = new Map<DBID, () => CtxAsync | null>();
 
 let initPromise: Promise<SQLite3> | null = null;
-function init(wasmUri?: string) {
+function init(wasmUri?: string, initializer: WasmInitializer = initWasm) {
   if (initPromise) {
     return initPromise;
   }
 
-  initPromise = initWasm(wasmUri ? () => wasmUri : undefined);
+  initPromise = initializer(wasmUri ? () => wasmUri : undefined);
   return initPromise;
 }
 

packages/ws-browserdb/src/index.ts

@@ -1,5 +1,8 @@
 import { DB } from "@vlcn.io/ws-client";
-import initWasm, { DB as WasmDB } from "@vlcn.io/crsqlite-wasm";
+import initWasm, {
+  DB as WasmDB,
+  WasmInitializer,
+} from "@vlcn.io/crsqlite-wasm";
 import { Change } from "@vlcn.io/ws-common";
 import { StmtAsync, firstPick } from "@vlcn.io/xplat-api";
 import tblrx from "@vlcn.io/rx-tbl";
@@ -139,9 +142,9 @@ class WrappedDB implements DB {
  */
 export function createDbProvider(
   wasmUri?: string
-): (dbname: string) => PromiseLike<DB> {
-  return async (dbname: string): Promise<DB> => {
-    const sqlite = await initWasm(wasmUri ? () => wasmUri : undefined);
+): (dbname: string, initializer?: WasmInitializer) => PromiseLike<DB> {
+  return async (dbname: string, initializer = initWasm): Promise<DB> => {
+    const sqlite = await initializer(wasmUri ? () => wasmUri : undefined);
     const db = await sqlite.open(dbname);
 
     const [pullChangesetStmt, applyChangesetStmt, updatePeerTrackerStmt] =