@capgo/capacitor-fast-sql 7.0.1

package/dist/esm/web.js

@@ -0,0 +1,215 @@
+import { WebPlugin } from '@capacitor/core';
+/**
+ * Web implementation using sql.js (SQLite compiled to WebAssembly)
+ *
+ * This provides a compatible API on the web platform, storing databases
+ * in IndexedDB for persistence.
+ */
+export class CapgoCapacitorNativeSqlWeb extends WebPlugin {
+    constructor() {
+        super();
+        this.databases = new Map();
+        this.sqlPromise = null;
+        this.nextPort = 9000;
+        this.loadSqlJs();
+    }
+    /**
+     * Load sql.js library
+     */
+    async loadSqlJs() {
+        if (this.sqlPromise)
+            return;
+        this.sqlPromise = new Promise(async (resolve, reject) => {
+            try {
+                // Load sql.js from CDN
+                const script = document.createElement('script');
+                script.src =
+                    'https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.8.0/sql-wasm.js';
+                script.onload = async () => {
+                    const initSqlJs = window.initSqlJs;
+                    const SQL = await initSqlJs({
+                        locateFile: (file) => `https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.8.0/${file}`,
+                    });
+                    resolve(SQL);
+                };
+                script.onerror = reject;
+                document.head.appendChild(script);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async connect(options) {
+        const SQL = await this.sqlPromise;
+        // Check if database already exists in IndexedDB
+        const savedData = await this.loadFromIndexedDB(options.database);
+        let db;
+        if (savedData) {
+            db = new SQL.Database(savedData);
+        }
+        else {
+            db = new SQL.Database();
+        }
+        const token = this.generateToken();
+        const port = this.nextPort++;
+        this.databases.set(options.database, { db, token, port });
+        return {
+            port,
+            token,
+            database: options.database,
+        };
+    }
+    async disconnect(options) {
+        const dbInfo = this.databases.get(options.database);
+        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();
+        this.databases.delete(options.database);
+    }
+    async getServerInfo(options) {
+        const dbInfo = this.databases.get(options.database);
+        if (!dbInfo) {
+            throw new Error(`Database '${options.database}' is not connected`);
+        }
+        return {
+            port: dbInfo.port,
+            token: dbInfo.token,
+        };
+    }
+    async execute(options) {
+        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 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);
+            return {
+                rows,
+                rowsAffected: changes,
+                insertId: insertId > 0 ? insertId : undefined,
+            };
+        }
+        catch (error) {
+            throw new Error(`SQL execution failed: ${error.message}`);
+        }
+    }
+    async beginTransaction(options) {
+        await this.execute({
+            database: options.database,
+            statement: 'BEGIN TRANSACTION',
+        });
+    }
+    async commitTransaction(options) {
+        await this.execute({
+            database: options.database,
+            statement: 'COMMIT',
+        });
+    }
+    async rollbackTransaction(options) {
+        await this.execute({
+            database: options.database,
+            statement: 'ROLLBACK',
+        });
+    }
+    /**
+     * Generate a random authentication token
+     */
+    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" };
+    }
+}