@anfenn/dync 1.0.0

package/dist/wa-sqlite.d.ts

@@ -0,0 +1,175 @@
+import { S as SQLiteDatabaseDriver, a as SQLiteRunResult, b as SQLiteQueryResult } from './types-CSbIAfu2.js';
+
+/**
+ * Virtual File System (VFS) options for wa-sqlite.
+ * Each VFS has different trade-offs for performance, durability, and compatibility.
+ *
+ * @see https://github.com/rhashimoto/wa-sqlite/tree/master/src/examples#vfs-comparison
+ */
+type WaSqliteVfsType = 
+/**
+ * IDBBatchAtomicVFS - IndexedDB-backed storage
+ * - Works on ALL contexts (Window, Worker, SharedWorker, service worker)
+ * - Supports multiple connections
+ * - Full durability with batch atomic writes
+ * - Good general-purpose choice for maximum compatibility
+ * @recommended For apps that need to work in main thread and don't need OPFS
+ */
+'IDBBatchAtomicVFS'
+/**
+ * IDBMirrorVFS - IndexedDB with in-memory mirror
+ * - Works on ALL contexts
+ * - Supports multiple connections
+ * - Much faster than IDBBatchAtomicVFS
+ * - Database must fit in available memory
+ * @recommended For small databases where performance is critical
+ */
+ | 'IDBMirrorVFS'
+/**
+ * OPFSCoopSyncVFS - OPFS with cooperative synchronous access
+ * - Requires Worker context
+ * - Supports multiple connections
+ * - Filesystem transparent (can import/export files)
+ * - Good balance of performance and compatibility
+ * @recommended For apps needing OPFS with multi-connection support
+ */
+ | 'OPFSCoopSyncVFS'
+/**
+ * AccessHandlePoolVFS - OPFS-backed storage (fastest single connection)
+ * - Requires Worker context
+ * - Single connection only (no multi-tab support)
+ * - Best performance, supports WAL mode
+ * - NOT filesystem transparent
+ * @recommended For single-tab apps where performance is critical
+ */
+ | 'AccessHandlePoolVFS';
+/**
+ * Options for configuring the WaSqliteDriver.
+ */
+interface WaSqliteDriverOptions {
+    /**
+     * Virtual File System to use for storage.
+     * @default 'IDBBatchAtomicVFS'
+     */
+    vfs?: WaSqliteVfsType;
+    /**
+     * Directory path for the database in OPFS VFS modes.
+     * Only used with OPFS-based VFS types.
+     * @default '/'
+     */
+    directory?: string;
+    /**
+     * SQLite page size in bytes.
+     * Larger pages can improve read performance for large BLOBs.
+     * Cannot be changed after database creation for IDBBatchAtomicVFS/IDBMirrorVFS.
+     * @default 4096
+     */
+    pageSize?: number;
+    /**
+     * SQLite cache size in pages (negative = KB, positive = pages).
+     * Larger cache improves performance but uses more memory.
+     * For IDBBatchAtomicVFS, must be large enough to hold journal for batch atomic mode.
+     * @default -2000 (2MB)
+     */
+    cacheSize?: number;
+    /**
+     * Enable WAL (Write-Ahead Logging) mode.
+     * Only supported with AccessHandlePoolVFS (with locking_mode=exclusive).
+     * For other VFS types, this is ignored.
+     * @default false
+     */
+    wal?: boolean;
+    /**
+     * Set synchronous pragma for durability vs performance trade-off.
+     * - 'full': Maximum durability (default)
+     * - 'normal': Relaxed durability, better performance (supported by IDBBatchAtomicVFS, IDBMirrorVFS, OPFSPermutedVFS)
+     * - 'off': No sync, fastest but risks data loss on crash
+     * @default 'full'
+     */
+    synchronous?: 'full' | 'normal' | 'off';
+}
+/**
+ * SQLite driver for web browsers using wa-sqlite with IndexedDB or OPFS persistence.
+ * Provides robust, persistent SQLite storage in the browser that prevents data loss.
+ *
+ * ## Data Safety Features
+ *
+ * - **IDBBatchAtomicVFS** (default): Uses IndexedDB batch atomic writes to ensure transactions
+ *   are either fully committed or not at all. Multi-tab safe.
+ * - **IDBMirrorVFS**: IndexedDB with in-memory mirror. Much faster, database must fit in RAM.
+ * - **OPFSCoopSyncVFS**: OPFS with cooperative sync. Multi-connection, filesystem transparent.
+ * - **AccessHandlePoolVFS**: Uses OPFS Access Handles for high performance. Single-tab only.
+ * - Full durability by default (`PRAGMA synchronous=full`)
+ * - Automatic journal mode configuration for each VFS type
+ *
+ * ## VFS Selection Guide
+ *
+ * | VFS | Best For | Multi-Tab | Speed |
+ * |-----|----------|-----------|-------|
+ * | IDBBatchAtomicVFS | General use, main thread | ✅ | Good |
+ * | IDBMirrorVFS | Small DBs, main thread | ✅ | Fast |
+ * | OPFSCoopSyncVFS | Web Workers, file export | ✅ | Good |
+ * | AccessHandlePoolVFS | Single-tab performance | ❌ | Fastest |
+ *
+ * @example
+ * ```ts
+ * import { WaSqliteDriver } from '@anfenn/dync/wa-sqlite';
+ * import { SQLiteAdapter } from '@anfenn/dync';
+ *
+ * // Default: IDBBatchAtomicVFS (works in main thread, multi-tab safe)
+ * const driver = new WaSqliteDriver('myapp.db');
+ *
+ * // For OPFS (faster, requires Worker, filesystem transparent)
+ * const opfsDriver = new WaSqliteDriver('myapp.db', { vfs: 'OPFSCoopSyncVFS' });
+ *
+ * const adapter = new SQLiteAdapter('myapp', driver);
+ * ```
+ */
+declare class WaSqliteDriver implements SQLiteDatabaseDriver {
+    readonly type = "WaSqliteDriver";
+    private db;
+    private sqlite3;
+    private readonly options;
+    private opened;
+    private openPromise;
+    private executionLock;
+    readonly name: string;
+    constructor(databaseName: string, options?: WaSqliteDriverOptions);
+    /**
+     * Execute a callback with exclusive database access.
+     * This prevents concurrent operations which can corrupt the database.
+     */
+    private withLock;
+    open(): Promise<void>;
+    private _open;
+    private loadWasmModule;
+    private createVFS;
+    private buildDatabasePath;
+    private configurePragmas;
+    close(): Promise<void>;
+    execute(statement: string): Promise<void>;
+    run(statement: string, values?: unknown[]): Promise<SQLiteRunResult>;
+    /**
+     * Convert values for SQLite compatibility.
+     * - Booleans must be converted to integers (SQLite has no boolean type)
+     */
+    private convertValues;
+    query(statement: string, values?: unknown[]): Promise<SQLiteQueryResult>;
+    /**
+     * Check if the database is currently open.
+     */
+    isOpen(): boolean;
+    /**
+     * Get the VFS type being used by this driver.
+     */
+    getVfsType(): WaSqliteVfsType;
+    /**
+     * Delete the database.
+     * This will close the database if open and remove all persisted data.
+     * For IndexedDB-based VFS, this deletes the IndexedDB database.
+     * For OPFS-based VFS, this removes the files from OPFS.
+     */
+    delete(): Promise<void>;
+}
+
+export { SQLiteDatabaseDriver, SQLiteQueryResult, SQLiteRunResult, WaSqliteDriver, type WaSqliteDriverOptions, type WaSqliteVfsType };

package/dist/wa-sqlite.js

@@ -0,0 +1,281 @@
+// src/storage/sqlite/drivers/WaSqliteDriver.ts
+var cachedModuleFactory = null;
+var cachedModule = null;
+var cachedSqlite3 = null;
+var registeredVFS = /* @__PURE__ */ new Map();
+var WaSqliteDriver = class {
+  type = "WaSqliteDriver";
+  db = null;
+  sqlite3 = null;
+  options;
+  opened = false;
+  openPromise = null;
+  // Mutex to prevent concurrent database operations (critical for wa-sqlite)
+  executionLock = Promise.resolve();
+  name;
+  constructor(databaseName, options = {}) {
+    this.name = databaseName;
+    this.options = {
+      vfs: "IDBBatchAtomicVFS",
+      directory: "/",
+      pageSize: 4096,
+      cacheSize: -2e3,
+      wal: false,
+      synchronous: "full",
+      ...options
+    };
+  }
+  /**
+   * Execute a callback with exclusive database access.
+   * This prevents concurrent operations which can corrupt the database.
+   */
+  async withLock(fn) {
+    const previousLock = this.executionLock;
+    let releaseLock;
+    this.executionLock = new Promise((resolve) => {
+      releaseLock = resolve;
+    });
+    try {
+      await previousLock;
+      return await fn();
+    } finally {
+      releaseLock();
+    }
+  }
+  async open() {
+    if (this.opened) return;
+    if (this.openPromise) return this.openPromise;
+    this.openPromise = this._open();
+    try {
+      await this.openPromise;
+    } finally {
+      this.openPromise = null;
+    }
+  }
+  async _open() {
+    const module = await this.loadWasmModule();
+    if (!cachedSqlite3) {
+      const { Factory } = await import("@journeyapps/wa-sqlite");
+      cachedSqlite3 = Factory(module);
+    }
+    this.sqlite3 = cachedSqlite3;
+    const vfsName = `dync_${this.options.vfs}_${this.name}`.replace(/[^a-zA-Z0-9_-]/g, "_");
+    let existingVfs = registeredVFS.get(vfsName);
+    if (!existingVfs) {
+      existingVfs = await this.createVFS(module, vfsName);
+      this.sqlite3.vfs_register(existingVfs, true);
+      registeredVFS.set(vfsName, existingVfs);
+    }
+    const dbPath = this.buildDatabasePath();
+    this.db = await this.sqlite3.open_v2(dbPath);
+    await this.configurePragmas();
+    this.opened = true;
+  }
+  async loadWasmModule() {
+    if (!cachedModule) {
+      if (!cachedModuleFactory) {
+        const wasmModule = await import("@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs");
+        cachedModuleFactory = wasmModule.default;
+      }
+      cachedModule = await cachedModuleFactory();
+    }
+    return cachedModule;
+  }
+  async createVFS(module, vfsName) {
+    const vfsType = this.options.vfs;
+    let VFSClass;
+    let vfsOptions = void 0;
+    switch (vfsType) {
+      case "IDBBatchAtomicVFS": {
+        const mod = await import("@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js");
+        VFSClass = mod.IDBBatchAtomicVFS;
+        vfsOptions = { lockPolicy: "exclusive" };
+        break;
+      }
+      case "IDBMirrorVFS": {
+        const mod = await import("@journeyapps/wa-sqlite/src/examples/IDBMirrorVFS.js");
+        VFSClass = mod.IDBMirrorVFS;
+        break;
+      }
+      case "OPFSCoopSyncVFS": {
+        const mod = await import("@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js");
+        VFSClass = mod.OPFSCoopSyncVFS;
+        break;
+      }
+      case "AccessHandlePoolVFS": {
+        const mod = await import("@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js");
+        VFSClass = mod.AccessHandlePoolVFS;
+        break;
+      }
+      default:
+        throw new Error(`Unsupported VFS type: ${vfsType}`);
+    }
+    return VFSClass.create(vfsName, module, vfsOptions);
+  }
+  buildDatabasePath() {
+    const vfsType = this.options.vfs;
+    if (vfsType === "IDBBatchAtomicVFS" || vfsType === "IDBMirrorVFS") {
+      return this.name;
+    }
+    const directory = this.options.directory.replace(/\/$/, "");
+    return `${directory}/${this.name}`;
+  }
+  async configurePragmas() {
+    if (!this.db || !this.sqlite3) return;
+    try {
+      await this.sqlite3.exec(this.db, `PRAGMA page_size = ${this.options.pageSize}`);
+    } catch {
+    }
+    await this.sqlite3.exec(this.db, `PRAGMA cache_size = ${this.options.cacheSize}`);
+    if (this.options.wal && this.options.vfs === "AccessHandlePoolVFS") {
+      await this.sqlite3.exec(this.db, "PRAGMA locking_mode = exclusive");
+      await this.sqlite3.exec(this.db, "PRAGMA journal_mode = WAL");
+    }
+  }
+  async close() {
+    if (!this.opened || !this.db || !this.sqlite3) return;
+    await this.withLock(async () => {
+      try {
+        await this.sqlite3.exec(this.db, "PRAGMA wal_checkpoint(TRUNCATE)");
+      } catch {
+      }
+      await this.sqlite3.close(this.db);
+      this.db = null;
+      this.opened = false;
+    });
+  }
+  async execute(statement) {
+    await this.open();
+    if (!this.db || !this.sqlite3) {
+      throw new Error("Database not initialized");
+    }
+    await this.withLock(async () => {
+      await this.sqlite3.exec(this.db, statement);
+    });
+  }
+  async run(statement, values = []) {
+    await this.open();
+    if (!this.db || !this.sqlite3) {
+      throw new Error("Database not initialized");
+    }
+    return this.withLock(async () => {
+      const convertedValues = this.convertValues(values);
+      for await (const stmt of this.sqlite3.statements(this.db, statement)) {
+        if (stmt === null) {
+          break;
+        }
+        this.sqlite3.reset(stmt);
+        if (convertedValues.length > 0) {
+          this.sqlite3.bind_collection(stmt, convertedValues);
+        }
+        await this.sqlite3.step(stmt);
+      }
+      return {
+        changes: this.sqlite3.changes(this.db),
+        lastId: Number(this.sqlite3.last_insert_id(this.db))
+      };
+    });
+  }
+  /**
+   * Convert values for SQLite compatibility.
+   * - Booleans must be converted to integers (SQLite has no boolean type)
+   */
+  convertValues(values) {
+    return values.map((value) => {
+      if (typeof value === "boolean") {
+        return value ? 1 : 0;
+      }
+      return value;
+    });
+  }
+  async query(statement, values = []) {
+    await this.open();
+    if (!this.db || !this.sqlite3) {
+      throw new Error("Database not initialized");
+    }
+    return this.withLock(async () => {
+      const { SQLITE_ROW } = await import("@journeyapps/wa-sqlite");
+      const allRows = [];
+      let columns = [];
+      const convertedValues = this.convertValues(values);
+      for await (const stmt of this.sqlite3.statements(this.db, statement)) {
+        if (stmt === null) {
+          break;
+        }
+        this.sqlite3.reset(stmt);
+        if (convertedValues.length > 0) {
+          this.sqlite3.bind_collection(stmt, convertedValues);
+        }
+        if (columns.length === 0) {
+          columns = this.sqlite3.column_names(stmt);
+        }
+        while (await this.sqlite3.step(stmt) === SQLITE_ROW) {
+          const row = this.sqlite3.row(stmt);
+          allRows.push(row);
+        }
+      }
+      return { columns, values: allRows };
+    });
+  }
+  /**
+   * Check if the database is currently open.
+   */
+  isOpen() {
+    return this.opened;
+  }
+  /**
+   * Get the VFS type being used by this driver.
+   */
+  getVfsType() {
+    return this.options.vfs;
+  }
+  /**
+   * Delete the database.
+   * This will close the database if open and remove all persisted data.
+   * For IndexedDB-based VFS, this deletes the IndexedDB database.
+   * For OPFS-based VFS, this removes the files from OPFS.
+   */
+  async delete() {
+    if (this.opened) {
+      await this.close();
+    }
+    const vfsType = this.options.vfs;
+    if (vfsType === "IDBBatchAtomicVFS" || vfsType === "IDBMirrorVFS") {
+      await new Promise((resolve, reject) => {
+        const request = indexedDB.deleteDatabase(this.name);
+        request.onsuccess = () => resolve();
+        request.onerror = () => reject(request.error);
+        request.onblocked = () => {
+          console.warn(`Database deletion blocked for ${this.name}. Close all connections and try again.`);
+        };
+      });
+    } else {
+      const dbPath = this.buildDatabasePath();
+      const root = await navigator.storage.getDirectory();
+      try {
+        const pathParts = dbPath.split("/").filter(Boolean);
+        let current = root;
+        for (let i = 0; i < pathParts.length - 1; i++) {
+          current = await current.getDirectoryHandle(pathParts[i]);
+        }
+        const filename = pathParts[pathParts.length - 1];
+        await current.removeEntry(filename, { recursive: true });
+        const associatedFiles = [`${filename}-journal`, `${filename}-wal`, `${filename}-shm`];
+        for (const file of associatedFiles) {
+          try {
+            await current.removeEntry(file, { recursive: false });
+          } catch {
+          }
+        }
+      } catch (error) {
+        if (error.name !== "NotFoundError") {
+          throw error;
+        }
+      }
+    }
+  }
+};
+export {
+  WaSqliteDriver
+};
+//# sourceMappingURL=wa-sqlite.js.map

package/dist/wa-sqlite.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/storage/sqlite/drivers/WaSqliteDriver.ts"],"sourcesContent":["import type { SQLiteDatabaseDriver, SQLiteQueryResult, SQLiteRunResult } from '../types';\n\n/**\n * Virtual File System (VFS) options for wa-sqlite.\n * Each VFS has different trade-offs for performance, durability, and compatibility.\n *\n * @see https://github.com/rhashimoto/wa-sqlite/tree/master/src/examples#vfs-comparison\n */\nexport type WaSqliteVfsType =\n    /**\n     * IDBBatchAtomicVFS - IndexedDB-backed storage\n     * - Works on ALL contexts (Window, Worker, SharedWorker, service worker)\n     * - Supports multiple connections\n     * - Full durability with batch atomic writes\n     * - Good general-purpose choice for maximum compatibility\n     * @recommended For apps that need to work in main thread and don't need OPFS\n     */\n    | 'IDBBatchAtomicVFS'\n    /**\n     * IDBMirrorVFS - IndexedDB with in-memory mirror\n     * - Works on ALL contexts\n     * - Supports multiple connections\n     * - Much faster than IDBBatchAtomicVFS\n     * - Database must fit in available memory\n     * @recommended For small databases where performance is critical\n     */\n    | 'IDBMirrorVFS'\n    /**\n     * OPFSCoopSyncVFS - OPFS with cooperative synchronous access\n     * - Requires Worker context\n     * - Supports multiple connections\n     * - Filesystem transparent (can import/export files)\n     * - Good balance of performance and compatibility\n     * @recommended For apps needing OPFS with multi-connection support\n     */\n    | 'OPFSCoopSyncVFS'\n    /**\n     * AccessHandlePoolVFS - OPFS-backed storage (fastest single connection)\n     * - Requires Worker context\n     * - Single connection only (no multi-tab support)\n     * - Best performance, supports WAL mode\n     * - NOT filesystem transparent\n     * @recommended For single-tab apps where performance is critical\n     */\n    | 'AccessHandlePoolVFS';\n\n/**\n * Options for configuring the WaSqliteDriver.\n */\nexport interface WaSqliteDriverOptions {\n    /**\n     * Virtual File System to use for storage.\n     * @default 'IDBBatchAtomicVFS'\n     */\n    vfs?: WaSqliteVfsType;\n\n    /**\n     * Directory path for the database in OPFS VFS modes.\n     * Only used with OPFS-based VFS types.\n     * @default '/'\n     */\n    directory?: string;\n\n    /**\n     * SQLite page size in bytes.\n     * Larger pages can improve read performance for large BLOBs.\n     * Cannot be changed after database creation for IDBBatchAtomicVFS/IDBMirrorVFS.\n     * @default 4096\n     */\n    pageSize?: number;\n\n    /**\n     * SQLite cache size in pages (negative = KB, positive = pages).\n     * Larger cache improves performance but uses more memory.\n     * For IDBBatchAtomicVFS, must be large enough to hold journal for batch atomic mode.\n     * @default -2000 (2MB)\n     */\n    cacheSize?: number;\n\n    /**\n     * Enable WAL (Write-Ahead Logging) mode.\n     * Only supported with AccessHandlePoolVFS (with locking_mode=exclusive).\n     * For other VFS types, this is ignored.\n     * @default false\n     */\n    wal?: boolean;\n\n    /**\n     * Set synchronous pragma for durability vs performance trade-off.\n     * - 'full': Maximum durability (default)\n     * - 'normal': Relaxed durability, better performance (supported by IDBBatchAtomicVFS, IDBMirrorVFS, OPFSPermutedVFS)\n     * - 'off': No sync, fastest but risks data loss on crash\n     * @default 'full'\n     */\n    synchronous?: 'full' | 'normal' | 'off';\n}\n\n// Internal VFS interface for lifecycle management\ninterface WaSqliteVFS {\n    close(): Promise<void>;\n    name: string;\n}\n\n// VFS class type with static create method\ninterface VFSClass {\n    create(name: string, module: any, options?: any): Promise<WaSqliteVFS>;\n}\n\n// Cached module factory and instance\nlet cachedModuleFactory: (() => Promise<any>) | null = null;\nlet cachedModule: any = null;\nlet cachedSqlite3: any = null;\n// Track VFS instances by name to avoid re-registering\nconst registeredVFS = new Map<string, WaSqliteVFS>();\n\n/**\n * SQLite driver for web browsers using wa-sqlite with IndexedDB or OPFS persistence.\n * Provides robust, persistent SQLite storage in the browser that prevents data loss.\n *\n * ## Data Safety Features\n *\n * - **IDBBatchAtomicVFS** (default): Uses IndexedDB batch atomic writes to ensure transactions\n *   are either fully committed or not at all. Multi-tab safe.\n * - **IDBMirrorVFS**: IndexedDB with in-memory mirror. Much faster, database must fit in RAM.\n * - **OPFSCoopSyncVFS**: OPFS with cooperative sync. Multi-connection, filesystem transparent.\n * - **AccessHandlePoolVFS**: Uses OPFS Access Handles for high performance. Single-tab only.\n * - Full durability by default (`PRAGMA synchronous=full`)\n * - Automatic journal mode configuration for each VFS type\n *\n * ## VFS Selection Guide\n *\n * | VFS | Best For | Multi-Tab | Speed |\n * |-----|----------|-----------|-------|\n * | IDBBatchAtomicVFS | General use, main thread | ✅ | Good |\n * | IDBMirrorVFS | Small DBs, main thread | ✅ | Fast |\n * | OPFSCoopSyncVFS | Web Workers, file export | ✅ | Good |\n * | AccessHandlePoolVFS | Single-tab performance | ❌ | Fastest |\n *\n * @example\n * ```ts\n * import { WaSqliteDriver } from '@anfenn/dync/wa-sqlite';\n * import { SQLiteAdapter } from '@anfenn/dync';\n *\n * // Default: IDBBatchAtomicVFS (works in main thread, multi-tab safe)\n * const driver = new WaSqliteDriver('myapp.db');\n *\n * // For OPFS (faster, requires Worker, filesystem transparent)\n * const opfsDriver = new WaSqliteDriver('myapp.db', { vfs: 'OPFSCoopSyncVFS' });\n *\n * const adapter = new SQLiteAdapter('myapp', driver);\n * ```\n */\nexport class WaSqliteDriver implements SQLiteDatabaseDriver {\n    readonly type = 'WaSqliteDriver';\n    private db: number | null = null;\n    private sqlite3: any = null;\n    private readonly options: Required<WaSqliteDriverOptions>;\n    private opened = false;\n    private openPromise: Promise<void> | null = null;\n    // Mutex to prevent concurrent database operations (critical for wa-sqlite)\n    private executionLock: Promise<void> = Promise.resolve();\n    readonly name: string;\n\n    constructor(databaseName: string, options: WaSqliteDriverOptions = {}) {\n        this.name = databaseName;\n        this.options = {\n            vfs: 'IDBBatchAtomicVFS',\n            directory: '/',\n            pageSize: 4096,\n            cacheSize: -2000,\n            wal: false,\n            synchronous: 'full',\n            ...options,\n        };\n    }\n\n    /**\n     * Execute a callback with exclusive database access.\n     * This prevents concurrent operations which can corrupt the database.\n     */\n    private async withLock<T>(fn: () => Promise<T>): Promise<T> {\n        // Chain onto the existing lock\n        const previousLock = this.executionLock;\n        let releaseLock: () => void;\n        this.executionLock = new Promise<void>((resolve) => {\n            releaseLock = resolve;\n        });\n\n        try {\n            // Wait for previous operation to complete\n            await previousLock;\n            // Execute our operation\n            return await fn();\n        } finally {\n            // Release the lock\n            releaseLock!();\n        }\n    }\n\n    async open(): Promise<void> {\n        if (this.opened) return;\n        if (this.openPromise) return this.openPromise;\n\n        this.openPromise = this._open();\n\n        try {\n            await this.openPromise;\n        } finally {\n            this.openPromise = null;\n        }\n    }\n\n    private async _open(): Promise<void> {\n        // Load wa-sqlite module (asyncify build for async VFS support)\n        const module = await this.loadWasmModule();\n\n        // Create SQLite API from module (cached - must only create once per module)\n        if (!cachedSqlite3) {\n            const { Factory } = await import('@journeyapps/wa-sqlite');\n            cachedSqlite3 = Factory(module);\n        }\n        this.sqlite3 = cachedSqlite3;\n\n        // For IDB-based VFS, the VFS name is also used as the IndexedDB database name\n        // Use a unique name based on database name to avoid conflicts\n        const vfsName = `dync_${this.options.vfs}_${this.name}`.replace(/[^a-zA-Z0-9_-]/g, '_');\n\n        // Reuse existing VFS instance or create and register a new one\n        let existingVfs = registeredVFS.get(vfsName);\n        if (!existingVfs) {\n            existingVfs = await this.createVFS(module, vfsName);\n            // Register VFS with SQLite as default (like PowerSync does)\n            this.sqlite3.vfs_register(existingVfs, true);\n            registeredVFS.set(vfsName, existingVfs);\n        }\n\n        // Build database path - for IDB VFS, this is the \"file\" path within the VFS\n        const dbPath = this.buildDatabasePath();\n\n        // Open database (VFS is registered as default)\n        this.db = await this.sqlite3.open_v2(dbPath);\n\n        // Configure database pragmas for performance and durability\n        await this.configurePragmas();\n\n        this.opened = true;\n    }\n\n    private async loadWasmModule(): Promise<any> {\n        if (!cachedModule) {\n            if (!cachedModuleFactory) {\n                // Dynamically import the asyncify build for async VFS support\n                const wasmModule = await import('@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs');\n                cachedModuleFactory = wasmModule.default;\n            }\n            // Cache the module instance - all VFS and sqlite3 APIs must share the same module\n            cachedModule = await cachedModuleFactory();\n        }\n        return cachedModule;\n    }\n\n    private async createVFS(module: any, vfsName: string): Promise<WaSqliteVFS> {\n        const vfsType = this.options.vfs;\n        let VFSClass: VFSClass;\n        let vfsOptions: any = undefined;\n\n        // Dynamically import VFS implementation\n        // Note: We cast to unknown first because the package types don't include the static create method\n        switch (vfsType) {\n            case 'IDBBatchAtomicVFS': {\n                const mod = await import('@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js');\n                VFSClass = mod.IDBBatchAtomicVFS as unknown as VFSClass;\n                // Use exclusive lock policy like PowerSync does\n                vfsOptions = { lockPolicy: 'exclusive' };\n                break;\n            }\n            case 'IDBMirrorVFS': {\n                const mod = await import('@journeyapps/wa-sqlite/src/examples/IDBMirrorVFS.js');\n                VFSClass = mod.IDBMirrorVFS as unknown as VFSClass;\n                break;\n            }\n            case 'OPFSCoopSyncVFS': {\n                const mod = await import('@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js');\n                VFSClass = mod.OPFSCoopSyncVFS as unknown as VFSClass;\n                break;\n            }\n            case 'AccessHandlePoolVFS': {\n                const mod = await import('@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js');\n                VFSClass = mod.AccessHandlePoolVFS as unknown as VFSClass;\n                break;\n            }\n            default:\n                throw new Error(`Unsupported VFS type: ${vfsType}`);\n        }\n\n        return VFSClass.create(vfsName, module, vfsOptions);\n    }\n\n    private buildDatabasePath(): string {\n        const vfsType = this.options.vfs;\n\n        // For IDB-based VFS, use database name directly\n        if (vfsType === 'IDBBatchAtomicVFS' || vfsType === 'IDBMirrorVFS') {\n            return this.name;\n        }\n\n        // For OPFS-based VFS, build full path\n        const directory = this.options.directory.replace(/\\/$/, '');\n        return `${directory}/${this.name}`;\n    }\n\n    private async configurePragmas(): Promise<void> {\n        if (!this.db || !this.sqlite3) return;\n\n        // Page size can only be set on new/empty databases\n        // For IDBBatchAtomicVFS, it cannot be changed after creation\n        // Try to set it, but ignore errors if the database already exists\n        try {\n            await this.sqlite3.exec(this.db, `PRAGMA page_size = ${this.options.pageSize}`);\n        } catch {\n            // Page size already set, ignore\n        }\n\n        // Cache size for performance\n        await this.sqlite3.exec(this.db, `PRAGMA cache_size = ${this.options.cacheSize}`);\n\n        // WAL mode only for AccessHandlePoolVFS with exclusive locking\n        if (this.options.wal && this.options.vfs === 'AccessHandlePoolVFS') {\n            await this.sqlite3.exec(this.db, 'PRAGMA locking_mode = exclusive');\n            await this.sqlite3.exec(this.db, 'PRAGMA journal_mode = WAL');\n        }\n        // Note: For IDB-based VFS, we don't set journal_mode - let the VFS handle it\n    }\n\n    async close(): Promise<void> {\n        if (!this.opened || !this.db || !this.sqlite3) return;\n\n        // Wait for any pending operations to complete by acquiring the lock\n        await this.withLock(async () => {\n            // Ensure all data is flushed before closing\n            // This is critical for IDB-based VFS which batch writes\n            try {\n                await this.sqlite3!.exec(this.db!, 'PRAGMA wal_checkpoint(TRUNCATE)');\n            } catch {\n                // Ignore if WAL mode not enabled\n            }\n\n            await this.sqlite3!.close(this.db!);\n\n            // Don't close the shared VFS - it may be used by other connections\n            // The VFS will be cleaned up when all references are gone\n            this.db = null;\n            this.opened = false;\n        });\n    }\n\n    async execute(statement: string): Promise<void> {\n        await this.open();\n\n        if (!this.db || !this.sqlite3) {\n            throw new Error('Database not initialized');\n        }\n\n        await this.withLock(async () => {\n            await this.sqlite3.exec(this.db, statement);\n        });\n    }\n\n    async run(statement: string, values: unknown[] = []): Promise<SQLiteRunResult> {\n        await this.open();\n\n        if (!this.db || !this.sqlite3) {\n            throw new Error('Database not initialized');\n        }\n\n        return this.withLock(async () => {\n            // Convert values for SQLite (booleans -> integers)\n            const convertedValues = this.convertValues(values);\n\n            // Use statements() generator with proper binding\n            for await (const stmt of this.sqlite3.statements(this.db, statement)) {\n                if (stmt === null) {\n                    break;\n                }\n\n                // Reset statement before binding (critical for wa-sqlite)\n                this.sqlite3.reset(stmt);\n\n                // Bind parameters if any\n                if (convertedValues.length > 0) {\n                    this.sqlite3.bind_collection(stmt, convertedValues);\n                }\n\n                // Execute the statement\n                await this.sqlite3.step(stmt);\n            }\n\n            return {\n                changes: this.sqlite3.changes(this.db),\n                lastId: Number(this.sqlite3.last_insert_id(this.db)),\n            };\n        });\n    }\n\n    /**\n     * Convert values for SQLite compatibility.\n     * - Booleans must be converted to integers (SQLite has no boolean type)\n     */\n    private convertValues(values: unknown[]): unknown[] {\n        return values.map((value) => {\n            if (typeof value === 'boolean') {\n                return value ? 1 : 0;\n            }\n            return value;\n        });\n    }\n\n    async query(statement: string, values: unknown[] = []): Promise<SQLiteQueryResult> {\n        await this.open();\n\n        if (!this.db || !this.sqlite3) {\n            throw new Error('Database not initialized');\n        }\n\n        return this.withLock(async () => {\n            const { SQLITE_ROW } = await import('@journeyapps/wa-sqlite');\n            const allRows: unknown[][] = [];\n            let columns: string[] = [];\n\n            // Convert values for SQLite (booleans -> integers)\n            const convertedValues = this.convertValues(values);\n\n            // Use statements() generator with proper binding\n            for await (const stmt of this.sqlite3.statements(this.db, statement)) {\n                if (stmt === null) {\n                    break;\n                }\n\n                // Reset statement before binding (critical for wa-sqlite)\n                this.sqlite3.reset(stmt);\n\n                // Bind parameters if any\n                if (convertedValues.length > 0) {\n                    this.sqlite3.bind_collection(stmt, convertedValues);\n                }\n\n                // Get column names\n                if (columns.length === 0) {\n                    columns = this.sqlite3.column_names(stmt);\n                }\n\n                // Fetch all rows\n                while ((await this.sqlite3.step(stmt)) === SQLITE_ROW) {\n                    const row = this.sqlite3.row(stmt);\n                    allRows.push(row);\n                }\n            }\n\n            return { columns, values: allRows };\n        });\n    }\n\n    /**\n     * Check if the database is currently open.\n     */\n    isOpen(): boolean {\n        return this.opened;\n    }\n\n    /**\n     * Get the VFS type being used by this driver.\n     */\n    getVfsType(): WaSqliteVfsType {\n        return this.options.vfs;\n    }\n\n    /**\n     * Delete the database.\n     * This will close the database if open and remove all persisted data.\n     * For IndexedDB-based VFS, this deletes the IndexedDB database.\n     * For OPFS-based VFS, this removes the files from OPFS.\n     */\n    async delete(): Promise<void> {\n        // Close if open\n        if (this.opened) {\n            await this.close();\n        }\n\n        const vfsType = this.options.vfs;\n\n        if (vfsType === 'IDBBatchAtomicVFS' || vfsType === 'IDBMirrorVFS') {\n            // Delete IndexedDB database\n            await new Promise<void>((resolve, reject) => {\n                const request = indexedDB.deleteDatabase(this.name);\n                request.onsuccess = () => resolve();\n                request.onerror = () => reject(request.error);\n                request.onblocked = () => {\n                    console.warn(`Database deletion blocked for ${this.name}. Close all connections and try again.`);\n                };\n            });\n        } else {\n            // For OPFS-based VFS, remove the directory\n            const dbPath = this.buildDatabasePath();\n            const root = await navigator.storage.getDirectory();\n\n            try {\n                // Try to remove the file/directory\n                const pathParts = dbPath.split('/').filter(Boolean);\n                let current = root;\n\n                // Navigate to parent directory\n                for (let i = 0; i < pathParts.length - 1; i++) {\n                    current = await current.getDirectoryHandle(pathParts[i]!);\n                }\n\n                // Remove the database file\n                const filename = pathParts[pathParts.length - 1]!;\n                await current.removeEntry(filename, { recursive: true });\n\n                // Also try to remove associated journal/wal files\n                const associatedFiles = [`${filename}-journal`, `${filename}-wal`, `${filename}-shm`];\n                for (const file of associatedFiles) {\n                    try {\n                        await current.removeEntry(file, { recursive: false });\n                    } catch {\n                        // Ignore if file doesn't exist\n                    }\n                }\n            } catch (error) {\n                // Ignore if directory doesn't exist\n                if ((error as Error).name !== 'NotFoundError') {\n                    throw error;\n                }\n            }\n        }\n    }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,171 @@
+{
+  "name": "@anfenn/dync",
+  "version": "1.0.0",
+  "private": false,
+  "description": "Write once, run IndexedDB & SQLite with sync anywhere - React, React Native, Expo, Capacitor, Electron & Node.js",
+  "keywords": [],
+  "license": "MIT",
+  "author": "Adam Fennell",
+  "type": "module",
+  "react-native": "./src/index.native.ts",
+  "exports": {
+    ".": {
+      "react-native": "./src/index.native.ts",
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./dexie": {
+      "import": {
+        "types": "./dist/dexie.d.ts",
+        "default": "./dist/dexie.js"
+      },
+      "require": {
+        "types": "./dist/dexie.d.cts",
+        "default": "./dist/dexie.cjs"
+      }
+    },
+    "./expo-sqlite": {
+      "react-native": "./src/expoSqlite.ts",
+      "import": {
+        "types": "./dist/expoSqlite.d.ts",
+        "default": "./dist/expoSqlite.js"
+      },
+      "require": {
+        "types": "./dist/expoSqlite.d.cts",
+        "default": "./dist/expoSqlite.cjs"
+      }
+    },
+    "./react": {
+      "react-native": "./src/react/index.ts",
+      "import": {
+        "types": "./dist/react/index.d.ts",
+        "default": "./dist/react/index.js"
+      },
+      "require": {
+        "types": "./dist/react/index.d.cts",
+        "default": "./dist/react/index.cjs"
+      }
+    },
+    "./capacitor": {
+      "import": {
+        "types": "./dist/capacitor.d.ts",
+        "default": "./dist/capacitor.js"
+      },
+      "require": {
+        "types": "./dist/capacitor.d.cts",
+        "default": "./dist/capacitor.cjs"
+      }
+    },
+    "./node": {
+      "import": {
+        "types": "./dist/node.d.ts",
+        "default": "./dist/node.js"
+      },
+      "require": {
+        "types": "./dist/node.d.cts",
+        "default": "./dist/node.cjs"
+      }
+    },
+    "./wa-sqlite": {
+      "import": {
+        "types": "./dist/wa-sqlite.d.ts",
+        "default": "./dist/wa-sqlite.js"
+      },
+      "require": {
+        "types": "./dist/wa-sqlite.d.cts",
+        "default": "./dist/wa-sqlite.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "package.json",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "pnpm run format && pnpm run lint && pnpm exec tsc --noEmit && tsup",
+    "build:all": "pnpm run build && pnpm --filter react-capacitor build",
+    "dev": "tsup --watch",
+    "dev:capacitor": "pnpm --filter react-capacitor run dev",
+    "dev:expo:web": "pnpm --filter react-native-expo-sqlite web --clear",
+    "dev:expo:start": "pnpm --filter react-native-expo-sqlite start --clear",
+    "lint": "eslint . --fix \"src/**/*.{js,jsx,ts,tsx,json}\"",
+    "format": "prettier --write \"**/*.{ts,tsx,md}\"",
+    "size": "pnpm --filter size size",
+    "test": "pnpm --filter tests test",
+    "test:all": "pnpm --filter tests test:all",
+    "test:ci": "pnpm --filter tests test:ci",
+    "test:browser:full": "pnpm --filter tests test:browser:full",
+    "reinstall": "find . -name node_modules -type d -prune -exec rm -rf {} + && pnpm install"
+  },
+  "devDependencies": {
+    "@capacitor-community/sqlite": "7.0.2",
+    "@capgo/capacitor-fast-sql": "7.2.13",
+    "@eslint/js": "9.39.2",
+    "@types/better-sqlite3": "7.6.13",
+    "@types/react": "19.1.10",
+    "dexie": "^4.2.1",
+    "eslint": "9.39.2",
+    "expo-crypto": "15.0.8",
+    "expo-sqlite": "16.0.10",
+    "prettier": "3.7.4",
+    "react": "19.1.0",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.49.0",
+    "@journeyapps/wa-sqlite": "1.4.1"
+  },
+  "peerDependencies": {
+    "@journeyapps/wa-sqlite": ">=1.0.0",
+    "@capacitor-community/sqlite": ">=7.0.0",
+    "@capgo/capacitor-fast-sql": ">=7.0.0",
+    "better-sqlite3": ">=11.0.0",
+    "dexie": ">=4.0.0",
+    "expo-crypto": ">=15.0.0",
+    "expo-sqlite": ">=16.0.0",
+    "react": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@journeyapps/wa-sqlite": {
+      "optional": true
+    },
+    "@capacitor-community/sqlite": {
+      "optional": true
+    },
+    "@capgo/capacitor-fast-sql": {
+      "optional": true
+    },
+    "better-sqlite3": {
+      "optional": true
+    },
+    "dexie": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "expo-crypto": {
+      "optional": true
+    },
+    "expo-sqlite": {
+      "optional": true
+    }
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "better-sqlite3",
+      "esbuild",
+      "unrs-resolver"
+    ]
+  }
+}