@capgo/capacitor-fast-sql 8.1.1 → 8.2.0

package/dist/plugin.cjs.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var core = require('@capacitor/core');
+var sqliteWasm = require('@sqlite.org/sqlite-wasm');
 
 /**
  * Transaction isolation levels
@@ -1071,91 +1072,75 @@ FastSQLVectorStore.connectionRefs = new Map();
 FastSQLVectorStore.ownedConnections = new Set();
 
 /**
- * Apply optional SQLite performance PRAGMAs after opening a database.
- */
-function applyPerformanceConfig(db, options) {
-    db.run('PRAGMA foreign_keys = ON');
-    if (options.walMode) {
-        db.run('PRAGMA journal_mode = WAL');
-    }
-    if (options.performancePresets) {
-        db.run('PRAGMA synchronous = NORMAL');
-        db.run('PRAGMA busy_timeout = 5000');
-        db.run('PRAGMA cache_size = -2000');
-    }
-}
-
-const DEFAULT_SQLJS_URL = 'https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.8.0/sql-wasm.js';
-const DEFAULT_WASM_URL = 'https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.8.0/sql-wasm.wasm';
-/**
- * Web implementation using sql.js (SQLite compiled to WebAssembly)
+ * Web implementation using the official SQLite Wasm build with OPFS persistence.
  *
- * This provides a compatible API on the web platform, storing databases
- * in IndexedDB for persistence.
+ * Databases are stored in the Origin Private File System when available (requires
+ * Cross-Origin Isolation: COOP/COEP). No full-database copy is kept in RAM or
+ * IndexedDB — SQLite reads/writes the OPFS file directly from a worker.
  */
 class CapgoCapacitorFastSqlWeb extends core.WebPlugin {
     constructor() {
-        super();
+        super(...arguments);
         this.databases = new Map();
-        this.sqlPromise = null;
+        this.promiserPromise = null;
         this.nextPort = 9000;
         this.webConfig = {};
     }
     /**
      * Configure web-specific options (no-op on native platforms).
-     * Must be called before connect() when using locally bundled sql.js files.
+     * Must be called before connect() when overriding the default worker.
      */
     async configureWeb(config) {
         this.webConfig = config;
-        // Reset any in-progress load so the next connect() uses the new config
-        this.sqlPromise = null;
+        this.promiserPromise = null;
     }
-    /**
-     * Load sql.js library (lazy – called on first connect()).
-     * Returns the cached promise so callers can await it directly.
-     */
-    loadSqlJs() {
-        var _a, _b;
-        if (!this.sqlPromise) {
-            const jsUrl = (_a = this.webConfig.sqlJsUrl) !== null && _a !== void 0 ? _a : DEFAULT_SQLJS_URL;
-            const wasmUrl = (_b = this.webConfig.wasmUrl) !== null && _b !== void 0 ? _b : DEFAULT_WASM_URL;
-            this.sqlPromise = new Promise((resolve, reject) => {
-                try {
-                    // Load sql.js from the configured URL (CDN or local bundle)
-                    const script = document.createElement('script');
-                    script.src = jsUrl;
-                    script.onload = async () => {
-                        const initSqlJs = window.initSqlJs;
-                        const SQL = await initSqlJs({
-                            locateFile: (file) => (file.endsWith('.wasm') ? wasmUrl : file),
-                        });
-                        resolve(SQL);
-                    };
-                    script.onerror = reject;
-                    document.head.appendChild(script);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
+    getPromiser() {
+        if (!this.promiserPromise) {
+            const config = this.webConfig.worker !== undefined ? { worker: this.webConfig.worker } : undefined;
+            this.promiserPromise = sqliteWasm.sqlite3Worker1Promiser.v2(config);
         }
-        return this.sqlPromise;
+        return this.promiserPromise;
+    }
+    dbPath(database) {
+        return `/capgo-fast-sql/${database}.sqlite3`;
     }
     async connect(options) {
-        const SQL = await this.loadSqlJs();
-        // Check if database already exists in IndexedDB
-        const savedData = await this.loadFromIndexedDB(options.database);
-        let db;
-        if (savedData) {
-            db = new SQL.Database(savedData);
+        if (this.databases.has(options.database)) {
+            const existing = this.databases.get(options.database);
+            return {
+                port: existing.port,
+                token: existing.token,
+                database: options.database,
+            };
+        }
+        const promiser = await this.getPromiser();
+        const path = this.dbPath(options.database);
+        const useOpfs = this.webConfig.useOpfs !== false;
+        let openResult;
+        if (useOpfs) {
+            try {
+                openResult = await promiser('open', {
+                    filename: `file:${path}?vfs=opfs`,
+                });
+            }
+            catch (opfsError) {
+                console.warn('[CapgoCapacitorFastSql] OPFS unavailable; web database will not persist across reloads. ' +
+                    'Serve with Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp.', opfsError);
+                openResult = await promiser('open', { filename: path });
+            }
         }
         else {
-            db = new SQL.Database();
+            openResult = await promiser('open', { filename: path });
+        }
+        const dbId = openResult.result.dbId;
+        const persistent = Boolean(openResult.result.persistent);
+        if (!dbId) {
+            throw new Error('Failed to open SQLite Wasm database: missing dbId');
         }
-        applyPerformanceConfig(db, options);
+        await this.applyPerformanceConfig(promiser, dbId, options);
         const token = this.generateToken();
         const port = this.nextPort++;
-        this.databases.set(options.database, { db, token, port });
+        this.databases.set(options.database, { dbId, token, port, persistent });
         return {
             port,
             token,
@@ -1167,10 +1152,9 @@ class CapgoCapacitorFastSqlWeb extends core.WebPlugin {
         if (!dbInfo) {
             throw new Error(`Database '${options.database}' is not connected`);
         }
-        // Save to IndexedDB before closing
-        const data = dbInfo.db.export();
-        await this.saveToIndexedDB(options.database, data);
-        dbInfo.db.close();
+        const promiser = await this.getPromiser();
+        // OPFS-backed DBs persist automatically; no export/IndexedDB write needed.
+        await promiser({ type: 'close', dbId: dbInfo.dbId, args: {} });
         this.databases.delete(options.database);
     }
     async getServerInfo(options) {
@@ -1184,32 +1168,45 @@ class CapgoCapacitorFastSqlWeb extends core.WebPlugin {
         };
     }
     async execute(options) {
+        var _a, _b, _c, _d;
         const dbInfo = this.databases.get(options.database);
         if (!dbInfo) {
             throw new Error(`Database '${options.database}' is not connected`);
         }
         try {
-            const stmt = dbInfo.db.prepare(options.statement);
-            if (options.params) {
-                stmt.bind(options.params);
-            }
+            const promiser = await this.getPromiser();
             const rows = [];
-            while (stmt.step()) {
-                const row = stmt.getAsObject();
-                rows.push(row);
-            }
-            stmt.free();
-            // Get changes and last insert ID
-            const changes = dbInfo.db.getRowsModified();
-            const insertId = this.getLastInsertId(dbInfo.db);
+            // countChanges / lastInsertRowId are supported by Worker1 at runtime but
+            // omitted from the published Worker1ExecArgs typings.
+            const result = await promiser({
+                type: 'exec',
+                dbId: dbInfo.dbId,
+                args: {
+                    sql: options.statement,
+                    bind: options.params,
+                    rowMode: 'object',
+                    countChanges: true,
+                    lastInsertRowId: true,
+                    callback: (msg) => {
+                        if (msg.rowNumber != null && msg.row && typeof msg.row === 'object' && !Array.isArray(msg.row)) {
+                            rows.push(msg.row);
+                        }
+                    },
+                },
+            });
+            const execResult = result.result;
+            const rowsAffected = Number((_a = execResult.changeCount) !== null && _a !== void 0 ? _a : 0);
+            const rawInsertId = execResult.lastInsertRowId;
+            const insertId = rawInsertId !== undefined && rawInsertId !== null ? Number(rawInsertId) : undefined;
             return {
                 rows,
-                rowsAffected: changes,
-                insertId: insertId > 0 ? insertId : undefined,
+                rowsAffected,
+                insertId: insertId !== undefined && insertId > 0 ? insertId : undefined,
             };
         }
         catch (error) {
-            throw new Error(`SQL execution failed: ${error.message}`);
+            const message = (_d = (_c = (_b = error === null || error === void 0 ? void 0 : error.result) === null || _b === void 0 ? void 0 : _b.message) !== null && _c !== void 0 ? _c : error === null || error === void 0 ? void 0 : error.message) !== null && _d !== void 0 ? _d : String(error);
+            throw new Error(`SQL execution failed: ${message}`);
         }
     }
     async beginTransaction(options) {
@@ -1230,87 +1227,22 @@ class CapgoCapacitorFastSqlWeb extends core.WebPlugin {
             statement: 'ROLLBACK',
         });
     }
-    /**
-     * Generate a random authentication token
-     */
+    async applyPerformanceConfig(promiser, dbId, options) {
+        await promiser({ type: 'exec', dbId, args: { sql: 'PRAGMA foreign_keys = ON' } });
+        if (options.walMode) {
+            await promiser({ type: 'exec', dbId, args: { sql: 'PRAGMA journal_mode = WAL' } });
+        }
+        if (options.performancePresets) {
+            await promiser({ type: 'exec', dbId, args: { sql: 'PRAGMA synchronous = NORMAL' } });
+            await promiser({ type: 'exec', dbId, args: { sql: 'PRAGMA busy_timeout = 5000' } });
+            await promiser({ type: 'exec', dbId, args: { sql: 'PRAGMA cache_size = -2000' } });
+        }
+    }
     generateToken() {
         return Array.from(crypto.getRandomValues(new Uint8Array(32)))
             .map((b) => b.toString(16).padStart(2, '0'))
             .join('');
     }
-    /**
-     * Get last insert row ID
-     */
-    getLastInsertId(db) {
-        try {
-            const result = db.exec('SELECT last_insert_rowid()');
-            if (result.length > 0 && result[0].values.length > 0) {
-                return result[0].values[0][0];
-            }
-        }
-        catch (_a) {
-            // Ignore error
-        }
-        return -1;
-    }
-    /**
-     * Save database to IndexedDB
-     */
-    async saveToIndexedDB(dbName, data) {
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.open('CapacitorNativeSQL', 1);
-            request.onerror = () => reject(request.error);
-            request.onupgradeneeded = (event) => {
-                const db = event.target.result;
-                if (!db.objectStoreNames.contains('databases')) {
-                    db.createObjectStore('databases');
-                }
-            };
-            request.onsuccess = () => {
-                const db = request.result;
-                const transaction = db.transaction(['databases'], 'readwrite');
-                const store = transaction.objectStore('databases');
-                const putRequest = store.put(data, dbName);
-                putRequest.onsuccess = () => {
-                    db.close();
-                    resolve();
-                };
-                putRequest.onerror = () => {
-                    db.close();
-                    reject(putRequest.error);
-                };
-            };
-        });
-    }
-    /**
-     * Load database from IndexedDB
-     */
-    async loadFromIndexedDB(dbName) {
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.open('CapacitorNativeSQL', 1);
-            request.onerror = () => reject(request.error);
-            request.onupgradeneeded = (event) => {
-                const db = event.target.result;
-                if (!db.objectStoreNames.contains('databases')) {
-                    db.createObjectStore('databases');
-                }
-            };
-            request.onsuccess = () => {
-                const db = request.result;
-                const transaction = db.transaction(['databases'], 'readonly');
-                const store = transaction.objectStore('databases');
-                const getRequest = store.get(dbName);
-                getRequest.onsuccess = () => {
-                    db.close();
-                    resolve(getRequest.result || null);
-                };
-                getRequest.onerror = () => {
-                    db.close();
-                    reject(getRequest.error);
-                };
-            };
-        });
-    }
     async getPluginVersion() {
         return { version: 'web' };
     }