@unvired/react-native-unvired-sdk 0.0.21 → 0.0.23

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0021
+R-0.000.0023

package/dist/database/Database.d.ts

@@ -10,60 +10,9 @@ export declare class Database {
      */
     executeSql(query: string, params?: any[]): Promise<any[]>;
     /**
-     * Create a table
+     * Delete a database
      */
-    createTable(tableName: string, columns: Record<string, string>): Promise<void>;
-    /**
-     * Drop a table
-     */
-    dropTable(tableName: string): Promise<void>;
-    /**
-     * Insert a record
-     */
-    insert(tableName: string, data: Record<string, any>): Promise<number>;
-    /**
-     * Insert multiple records in a transaction
-     */
-    insertBatch(tableName: string, records: Record<string, any>[]): Promise<void>;
-    /**
-     * Update records
-     */
-    update(tableName: string, data: Record<string, any>, where: string, whereParams?: any[]): Promise<number>;
-    /**
-     * Delete records
-     */
-    delete(tableName: string, where: string, whereParams?: any[]): Promise<number>;
-    /**
-     * Select records
-     */
-    select(tableName: string, columns?: string[], where?: string, whereParams?: any[], orderBy?: string, limit?: number): Promise<any[]>;
-    /**
-     * Select a single record
-     */
-    selectOne(tableName: string, columns?: string[], where?: string, whereParams?: any[]): Promise<any | null>;
-    /**
-     * Count records
-     */
-    count(tableName: string, where?: string, whereParams?: any[]): Promise<number>;
-    /**
-     * Check if a table exists
-     */
-    tableExists(tableName: string): Promise<boolean>;
-    /**
-     * Get all table names
-     */
-    getAllTables(): Promise<string[]>;
-    /**
-     * Clear all data from a table
-     */
-    truncate(tableName: string): Promise<void>;
-    /**
-     * Execute multiple SQL statements in a transaction
-     */
-    transaction(queries: Array<{
-        query: string;
-        params?: any[];
-    }>): Promise<void>;
+    deleteDB(): Promise<void>;
 }
 /**
  * Create a new database instance

package/dist/database/Database.js

@@ -17,135 +17,13 @@ export class Database {
         });
     }
     /**
-     * Create a table
+     * Delete a database
      */
-    async createTable(tableName, columns) {
-        const columnDefs = Object.entries(columns)
-            .map(([name, type]) => `${name} ${type}`)
-            .join(', ');
-        const query = `CREATE TABLE IF NOT EXISTS ${tableName} (${columnDefs})`;
-        await this.executeSql(query);
-    }
-    /**
-     * Drop a table
-     */
-    async dropTable(tableName) {
-        const query = `DROP TABLE IF EXISTS ${tableName}`;
-        await this.executeSql(query);
-    }
-    /**
-     * Insert a record
-     */
-    async insert(tableName, data) {
-        var _a;
-        const columns = Object.keys(data).join(', ');
-        const placeholders = Object.keys(data).map(() => '?').join(', ');
-        const values = Object.values(data);
-        const query = `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders})`;
-        const result = await this.executeSql(query, values);
-        // Return the insert ID if available
-        return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.insertId) || 0;
-    }
-    /**
-     * Insert multiple records in a transaction
-     */
-    async insertBatch(tableName, records) {
-        if (records.length === 0)
-            return;
-        const columns = Object.keys(records[0]).join(', ');
-        const placeholders = Object.keys(records[0]).map(() => '?').join(', ');
-        const query = `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders})`;
-        for (const record of records) {
-            const values = Object.values(record);
-            await this.executeSql(query, values);
-        }
-    }
-    /**
-     * Update records
-     */
-    async update(tableName, data, where, whereParams = []) {
-        var _a;
-        const setClause = Object.keys(data)
-            .map(key => `${key} = ?`)
-            .join(', ');
-        const values = [...Object.values(data), ...whereParams];
-        const query = `UPDATE ${tableName} SET ${setClause} WHERE ${where}`;
-        const result = await this.executeSql(query, values);
-        return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.rowsAffected) || 0;
-    }
-    /**
-     * Delete records
-     */
-    async delete(tableName, where, whereParams = []) {
-        var _a;
-        const query = `DELETE FROM ${tableName} WHERE ${where}`;
-        const result = await this.executeSql(query, whereParams);
-        return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.rowsAffected) || 0;
-    }
-    /**
-     * Select records
-     */
-    async select(tableName, columns = ['*'], where, whereParams = [], orderBy, limit) {
-        let query = `SELECT ${columns.join(', ')} FROM ${tableName}`;
-        if (where) {
-            query += ` WHERE ${where}`;
-        }
-        if (orderBy) {
-            query += ` ORDER BY ${orderBy}`;
-        }
-        if (limit) {
-            query += ` LIMIT ${limit}`;
-        }
-        return this.executeSql(query, whereParams);
-    }
-    /**
-     * Select a single record
-     */
-    async selectOne(tableName, columns = ['*'], where, whereParams = []) {
-        const results = await this.select(tableName, columns, where, whereParams, undefined, 1);
-        return results.length > 0 ? results[0] : null;
-    }
-    /**
-     * Count records
-     */
-    async count(tableName, where, whereParams = []) {
-        var _a;
-        let query = `SELECT COUNT(*) as count FROM ${tableName}`;
-        if (where) {
-            query += ` WHERE ${where}`;
-        }
-        const result = await this.executeSql(query, whereParams);
-        return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.count) || 0;
-    }
-    /**
-     * Check if a table exists
-     */
-    async tableExists(tableName) {
-        const query = `SELECT name FROM sqlite_master WHERE type='table' AND name=?`;
-        const result = await this.executeSql(query, [tableName]);
-        return result.length > 0;
-    }
-    /**
-     * Get all table names
-     */
-    async getAllTables() {
-        const query = `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;
-        const result = await this.executeSql(query);
-        return result.map(row => row.name);
-    }
-    /**
-     * Clear all data from a table
-     */
-    async truncate(tableName) {
-        await this.executeSql(`DELETE FROM ${tableName}`);
-    }
-    /**
-     * Execute multiple SQL statements in a transaction
-     */
-    async transaction(queries) {
-        for (const { query, params } of queries) {
-            await this.executeSql(query, params || []);
-        }
+    async deleteDB() {
+        return new Promise((resolve, reject) => {
+            const adapter = DatabaseManager.getDatabaseAdapter();
+            adapter.deleteUserData({ dbName: this.dbName }, () => resolve(), (error) => reject(new Error(String(error))));
+        });
     }
 }
 /**

package/dist/database/DatabaseManager.d.ts

@@ -1,4 +1,4 @@
-import { IDatabaseAdapter } from './types';
+import { IDatabaseAdapter } from "./types";
 /**
  * DatabaseManager - Manages database operations across platforms
  * - iOS/Android/Windows: Uses @op-engineering/op-sqlite

package/dist/database/DatabaseManager.js

@@ -1,8 +1,6 @@
-import { Platform } from 'react-native';
-import { DatabaseNative } from './services/DatabaseNative';
-import { DatabaseWeb } from './services/DatabaseWeb';
+import { DatabaseNative } from "./services/DatabaseNative";
 // Select database implementation based on platform
-const dbImpl = Platform.OS === 'web' ? new DatabaseWeb() : new DatabaseNative();
+const dbImpl = new DatabaseNative();
 /**
  * DatabaseManager - Manages database operations across platforms
  * - iOS/Android/Windows: Uses @op-engineering/op-sqlite

package/dist/database/services/DatabaseNative.js

@@ -9,10 +9,9 @@ export class DatabaseNative {
         if (this.databases.has(dbKey)) {
             return this.databases.get(dbKey);
         }
-        // @op-engineering/op-sqlite open function
-        // We treat location as mainly advisory since op-sqlite defaults to valid paths.
-        // If strict paths are needed, we would need to construct absolute path using FS.
-        // For now, we rely on the name.
+        if (!name) {
+            throw new Error("Database name is required");
+        }
         const db = open({ name });
         this.databases.set(dbKey, db);
         return db;
@@ -29,43 +28,105 @@ export class DatabaseNative {
                 }
             },
             execute: async (options, successCallback, errorCallback) => {
-                var _a;
                 try {
                     const db = this.getDatabase(options.dbName);
-                    const res = db.execute(options.query, options.params);
-                    // op-sqlite v15+ returns rows as an array natively in most configurations
-                    // Check for _array for backward compatibility with some bridges or older habits
-                    // @ts-ignore
-                    const rows = ((_a = res.rows) === null || _a === void 0 ? void 0 : _a._array) || res.rows || [];
-                    successCallback(rows);
+                    // FIX: Await the result properly
+                    const res = await db.execute(options.query, options.params);
+                    let resultToReturn = [];
+                    // Cast to any to avoid TS error "Property '_array' does not exist on type 'never'"
+                    const rawRes = res;
+                    if (rawRes) {
+                        if (rawRes.rows) {
+                            const rawRows = rawRes.rows;
+                            if (Array.isArray(rawRows)) {
+                                resultToReturn = rawRows;
+                            }
+                            else if (rawRows._array && Array.isArray(rawRows._array)) {
+                                resultToReturn = rawRows._array;
+                            }
+                            else if (typeof rawRows.length === 'number') {
+                                // JSI iterator
+                                for (let i = 0; i < rawRows.length; i++) {
+                                    // Use item() if available, otherwise index access
+                                    const r = rawRows.item ? rawRows.item(i) : rawRows[i];
+                                    resultToReturn.push(r);
+                                }
+                            }
+                        }
+                        else if (Array.isArray(rawRes)) {
+                            resultToReturn = rawRes;
+                        }
+                        // Attach insertId if present (though interface usually expects strict array, 
+                        // JS runtime allows attaching props to array)
+                        if (rawRes.insertId !== undefined) {
+                            resultToReturn.insertId = rawRes.insertId;
+                            resultToReturn.rowsAffected = rawRes.rowsAffected;
+                        }
+                    }
+                    successCallback(resultToReturn);
                 }
                 catch (error) {
                     errorCallback(error instanceof Error ? error.message : String(error));
                 }
             },
             executeStatementOnPath: async (dbPath, sqlQuery, callback) => {
-                var _a, _b;
+                var _a;
                 try {
                     const dbName = ((_a = dbPath.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(".db", "")) || "default";
                     const db = this.getDatabase(dbName);
-                    const res = db.execute(sqlQuery);
-                    // @ts-ignore
-                    const rows = ((_b = res.rows) === null || _b === void 0 ? void 0 : _b._array) || res.rows || [];
-                    callback(rows);
+                    const res = await db.execute(sqlQuery);
+                    let resultToReturn = [];
+                    const rawRes = res;
+                    if (rawRes && rawRes.rows) {
+                        const rawRows = rawRes.rows;
+                        if (typeof rawRows.length === 'number') {
+                            for (let i = 0; i < rawRows.length; i++) {
+                                const r = rawRows.item ? rawRows.item(i) : rawRows[i];
+                                resultToReturn.push(r);
+                            }
+                        }
+                        else if (Array.isArray(rawRows)) {
+                            resultToReturn = rawRows;
+                        }
+                        else if (rawRows._array) {
+                            resultToReturn = rawRows._array;
+                        }
+                    }
+                    // Attach insertId if present
+                    if (rawRes && rawRes.insertId !== undefined) {
+                        resultToReturn.insertId = rawRes.insertId;
+                        resultToReturn.rowsAffected = rawRes.rowsAffected;
+                    }
+                    callback(resultToReturn);
                 }
                 catch (error) {
                     callback([]);
                 }
             },
             selectFromPath: async (dbPath, sqlQuery, callback) => {
-                var _a, _b;
+                var _a;
                 try {
                     const dbName = ((_a = dbPath.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(".db", "")) || "default";
                     const db = this.getDatabase(dbName);
-                    const res = db.execute(sqlQuery);
-                    // @ts-ignore
-                    const rows = ((_b = res.rows) === null || _b === void 0 ? void 0 : _b._array) || res.rows || [];
-                    callback(rows);
+                    const res = await db.execute(sqlQuery);
+                    let resultToReturn = [];
+                    const rawRes = res;
+                    if (rawRes && rawRes.rows) {
+                        const rawRows = rawRes.rows;
+                        if (typeof rawRows.length === 'number') {
+                            for (let i = 0; i < rawRows.length; i++) {
+                                const r = rawRows.item ? rawRows.item(i) : rawRows[i];
+                                resultToReturn.push(r);
+                            }
+                        }
+                        else if (Array.isArray(rawRows)) {
+                            resultToReturn = rawRows;
+                        }
+                        else if (rawRows._array) {
+                            resultToReturn = rawRows._array;
+                        }
+                    }
+                    callback(resultToReturn);
                 }
                 catch (error) {
                     callback([]);
@@ -106,7 +167,7 @@ export class DatabaseNative {
                         ? "DELETE FROM user_data WHERE user_id = ?"
                         : "DELETE FROM user_data";
                     const params = options.userId ? [options.userId] : [];
-                    db.execute(query, params);
+                    await db.execute(query, params);
                     callback();
                 }
                 catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unvired/react-native-unvired-sdk",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "Unvired SDK for React Native with logging, database, notifications, and file system support",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
@@ -12,14 +12,14 @@
     "format": "prettier --write \"src/**/*.{js,ts,tsx}\""
   },
   "peerDependencies": {
+    "@op-engineering/op-sqlite": "^15.2.5",
+    "@react-native-async-storage/async-storage": "^2.2.0",
+    "@react-native-firebase/messaging": "^21.8.1",
     "react": ">=18",
     "react-native": ">=0.73",
-    "react-native-fs": "^2.20.0",
     "react-native-device-info": "^15.0.1",
-    "@op-engineering/op-sqlite": "^15.2.5",
-    "react-native-zip-archive": "^7.0.2",
-    "@react-native-firebase/messaging": "^21.8.1",
-    "@react-native-async-storage/async-storage": "^2.2.0"
+    "react-native-fs": "^2.20.0",
+    "react-native-zip-archive": "^7.0.2"
   },
   "peerDependenciesMeta": {
     "@react-native-firebase/messaging": {
@@ -42,25 +42,23 @@
     }
   },
   "dependencies": {
-    "pako": "^2.1.0",
-    "sql.js": "^1.10.3"
+    "pako": "^2.1.0"
   },
   "devDependencies": {
-    "typescript": "^5.0.0",
+    "@op-engineering/op-sqlite": "^15.2.5",
+    "@react-native-async-storage/async-storage": "^2.2.0",
+    "@react-native-firebase/messaging": "^21.8.1",
+    "@types/pako": "^2.0.4",
+    "@types/react": ">=18",
+    "@types/react-native": "^0.73.0",
     "eslint": "^8.0.0",
     "jest": "^29.0.0",
     "prettier": "^3.0.0",
-    "@types/react": ">=18",
-    "@types/react-native": "^0.73.0",
     "react": "19.2.0",
     "react-native": "0.83.1",
-    "react-native-fs": "^2.20.0",
     "react-native-device-info": "^15.0.1",
-    "@op-engineering/op-sqlite": "^15.2.5",
-    "@react-native-firebase/messaging": "^21.8.1",
-    "@react-native-async-storage/async-storage": "^2.2.0",
-    "@types/pako": "^2.0.4",
-    "@types/sql.js": "^1.4.9"
+    "react-native-fs": "^2.20.0",
+    "typescript": "^5.0.0"
   },
   "engines": {
     "node": ">=18"
@@ -68,4 +66,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/ts-core/ReactNativePlatformAdapter.ts

@@ -1,32 +1,21 @@
-import { PlatformInterface, IDeviceInfo, IFileEntry, IDatabaseAdapter, IPushNotificationAdapter, ILoggerAdapter, DatabaseType } from './PlatformInterface';
-import { logger, LogLevel } from '../src/logger';
-import { RNFileEntry } from '../src/file-system/RNFileEntry';
-import { FileSystem } from '../src/file-system/FileSystem';
+import { DeviceInfo, DatabaseManager, LocalStorage, logger, LogLevel, PushNotification, FileSystem } from '@unvired/react-native-unvired-sdk';
+import { PlatformInterface, IDeviceInfo, IFileEntry, IDatabaseAdapter, IPushNotificationAdapter, ILoggerAdapter, IStorageAdapter } from './PlatformInterface';
+
 export class ReactNativePlatformAdapter implements PlatformInterface {
 
-    getDeviceInfo(): IDeviceInfo {
-        // TODO: Implement device info retrieval
-        return {
-            platform: 'unknown',
-            model: '',
-            version: '',
-            isMobile: true
-        };
+    async getDeviceInfo(): Promise<IDeviceInfo> {
+        return await DeviceInfo.getDeviceInfo();
     }
 
     getPlatform(): string {
-        // TODO: Implement platform retrieval
-        return "";
+        return DeviceInfo.getPlatform();
     }
 
     getFrontendType(): string {
-        // TODO: Implement frontend type retrieval
-        // Refer CordovaPlatformAdapter.ts for reference to return values
-        return "";
+        return DeviceInfo.getFrontendType();
     }
 
     getDocumentDirectory(): string {
-        // Return the document directory path for React Native
         return FileSystem.getDocumentDirectory();
     }
 
@@ -35,71 +24,66 @@ export class ReactNativePlatformAdapter implements PlatformInterface {
     }
 
     async getFolderBasedOnUserId(userId: string): Promise<string> {
-        return FileSystem.getFolderBasedOnUserId(userId);
+        return await FileSystem.getFolderBasedOnUserId(userId);
     }
 
     async deleteUserFolder(userId: string): Promise<void> {
-        return FileSystem.deleteUserFolder(userId);
+        await FileSystem.deleteUserFolder(userId);
     }
 
     getDatabaseAdapter(): IDatabaseAdapter {
-        // TODO: Implement database adapter
         return {
-            create: (options, successCallback, errorCallback) => {
-                // TODO: Implement database creation
+            create: (options: { userId: string }, successCallback, errorCallback) => {
+                // Map userId to dbName or pass appropriate options
+                DatabaseManager.getDatabaseAdapter().create({ name: options.userId }, successCallback, errorCallback);
             },
-            execute: (options, successCallback, errorCallback) => {
-                // TODO: Implement SQL execution
+            execute: (options: any, successCallback, errorCallback) => {
+                DatabaseManager.getDatabaseAdapter().execute(options, successCallback, errorCallback);
             },
             executeStatementOnPath: (dbPath, sqlQuery, callback) => {
-                // TODO: Implement SQL execution on specific path
-                callback([]);
+                DatabaseManager.getDatabaseAdapter().executeStatementOnPath(dbPath, sqlQuery, callback);
             },
             selectFromPath: (dbPath, sqlQuery, callback) => {
-                // TODO: Implement SELECT query
-                callback([]);
+                DatabaseManager.getDatabaseAdapter().selectFromPath(dbPath, sqlQuery, callback);
             },
             createDatabase: (dbPath, callback) => {
-                // TODO: Implement database creation
-                callback();
+                DatabaseManager.getDatabaseAdapter().createDatabase(dbPath, callback);
             },
-            getDBFilePath: (options, callback) => {
-                // TODO: Implement database file path retrieval
-                callback("");
+            getDBFilePath: (options: { dbType: string }, callback) => {
+                DatabaseManager.getDatabaseAdapter().getDBFilePath({ name: options.dbType }, callback);
             },
-            saveWebDB: (options, callback, errorCallback) => {
-                // TODO: Implement web database save
-                callback({});
+            saveWebDB: (options: { userId: string }, callback, errorCallback) => {
+                const dbName = options.userId;
+                const data = (options as any).data || {};
+                DatabaseManager.getDatabaseAdapter().saveWebDB({ dbName, data }, callback, errorCallback);
             },
-            exportWebDB: (options, callback, errorCallback) => {
-                // TODO: Implement web database export
-                callback({});
+            exportWebDB: (options: { userId: string }, callback, errorCallback) => {
+                DatabaseManager.getDatabaseAdapter().exportWebDB({ dbName: options.userId }, callback, errorCallback);
             },
-            deleteUserData: (options, callback, errorCallback) => {
-                // TODO: Implement user data deletion
-                callback();
+            deleteUserData: (options: { userId: string }, callback, errorCallback) => {
+                DatabaseManager.getDatabaseAdapter().deleteUserData({ dbName: options.userId, userId: options.userId }, callback, errorCallback);
             }
         };
     }
 
     getPushNotificationAdapter(): IPushNotificationAdapter | null {
         try {
+            const pushNotification = new PushNotification();
             return {
                 requestPermission: async (options = { forceShow: false }) => {
-                    //TODO: Implement push notification permission request
+                    await pushNotification.requestPermission(options);
                 },
                 getToken: async () => {
-                    //TODO: Implement push notification token retrieval
-                    return "";
+                    return await pushNotification.getToken();
                 },
                 onTokenRefresh: (callback) => {
-                    //TODO: Implement push notification token refresh
+                    pushNotification.onTokenRefresh(callback);
                 },
                 onMessage: (callback) => {
-                    //TODO: Implement push notification message handling
+                    pushNotification.onMessage(callback);
                 },
                 onBackgroundMessage: (callback) => {
-                    //TODO: Implement push notification background message handling
+                    pushNotification.onBackgroundMessage(callback);
                 }
             };
         } catch (error) {
@@ -110,58 +94,45 @@ export class ReactNativePlatformAdapter implements PlatformInterface {
     getLoggerAdapter(): ILoggerAdapter {
         return {
             logDebug: (sourceClass, method, message) => {
-                console.log(`[DEBUG] ${sourceClass}.${method}: ${message}`);
                 logger.logDebug(sourceClass, method, message);
-                // TODO: Implement log file writing
             },
             logError: (sourceClass, method, message) => {
-                console.error(`[ERROR] ${sourceClass}.${method}: ${message}`);
                 logger.logError(sourceClass, method, message);
-                // TODO: Implement log file writing
             },
             logInfo: (sourceClass, method, message) => {
-                console.info(`[INFO] ${sourceClass}.${method}: ${message}`);
                 logger.logInfo(sourceClass, method, message);
-                // TODO: Implement log file writing
             },
             setLogLevel: (logLevel: LogLevel) => {
-                // TODO: Implement log level setting
-                console.log(`Setting log level to: ${logLevel}`);
                 logger.setLogLevel(logLevel);
             },
             getLogFileURL: async () => {
-                // TODO: Implement log file URL retrieval
                 return logger.getLogFileURL();
             },
             getLogFileContent: async () => {
-                // TODO: Implement log file content retrieval
                 return logger.getLogFileContent();
             },
             getBackupLogFileContent: async () => {
-                // TODO: Implement backup log file content retrieval
-                const content = await logger.getBackupLogFileContent();
-                return content || '';
+                return logger.getBackupLogFileContent();
             },
             clearLogFile: async () => {
-                // TODO: Implement log file clearing
                 logger.clearLogFile();
             }
         };
     }
 
-    getStorageAdapter() {
+    getStorageAdapter(): IStorageAdapter {
         return {
             getItem: (key: string) => {
-                return null;
+                return LocalStorage.getItem(key);
             },
             setItem: (key: string, value: string) => {
-                // Dummy implementation
+                return LocalStorage.setItem(key, value);
             },
             removeItem: (key: string) => {
-                // Dummy implementation
+                return LocalStorage.removeItem(key);
             },
             clear: () => {
-                // Dummy implementation
+                return LocalStorage.clear();
             }
         };
     }

package/dist/database/services/DatabaseWeb.d.ts

@@ -1,13 +0,0 @@
-import { IDatabaseAdapter } from '../types';
-/**
- * DatabaseWeb - Web database implementation using sql.js
- * Uses SQLite compiled to WebAssembly for full SQLite compatibility in browsers
- */
-export declare class DatabaseWeb {
-    private databases;
-    private SQL;
-    private initSQL;
-    private getDatabase;
-    private executeQuery;
-    getAdapter(): IDatabaseAdapter;
-}

package/dist/database/services/DatabaseWeb.js

@@ -1,138 +0,0 @@
-import initSqlJs from 'sql.js';
-/**
- * DatabaseWeb - Web database implementation using sql.js
- * Uses SQLite compiled to WebAssembly for full SQLite compatibility in browsers
- */
-export class DatabaseWeb {
-    constructor() {
-        this.databases = new Map();
-        this.SQL = null;
-    }
-    async initSQL() {
-        if (!this.SQL) {
-            this.SQL = await initSqlJs({
-                locateFile: (file) => `https://sql.js.org/dist/${file}`
-            });
-        }
-        return this.SQL;
-    }
-    async getDatabase(name) {
-        if (this.databases.has(name)) {
-            return this.databases.get(name);
-        }
-        const SQL = await this.initSQL();
-        const db = new SQL.Database();
-        this.databases.set(name, db);
-        return db;
-    }
-    executeQuery(db, query, params = []) {
-        const results = [];
-        const stmt = db.prepare(query);
-        stmt.bind(params);
-        while (stmt.step()) {
-            const row = stmt.getAsObject();
-            results.push(row);
-        }
-        stmt.free();
-        return results;
-    }
-    getAdapter() {
-        return {
-            create: async (options, successCallback, errorCallback) => {
-                try {
-                    await this.getDatabase(options.name);
-                    successCallback({ success: true, database: options.name });
-                }
-                catch (error) {
-                    errorCallback(error instanceof Error ? error.message : String(error));
-                }
-            },
-            execute: async (options, successCallback, errorCallback) => {
-                try {
-                    const db = await this.getDatabase(options.dbName);
-                    const results = this.executeQuery(db, options.query, options.params);
-                    successCallback(results);
-                }
-                catch (error) {
-                    errorCallback(error instanceof Error ? error.message : String(error));
-                }
-            },
-            executeStatementOnPath: async (dbPath, sqlQuery, callback) => {
-                var _a;
-                try {
-                    const dbName = ((_a = dbPath.split('/').pop()) === null || _a === void 0 ? void 0 : _a.replace('.db', '')) || 'default';
-                    const db = await this.getDatabase(dbName);
-                    const results = this.executeQuery(db, sqlQuery);
-                    callback(results);
-                }
-                catch (error) {
-                    callback([]);
-                }
-            },
-            selectFromPath: async (dbPath, sqlQuery, callback) => {
-                var _a;
-                try {
-                    const dbName = ((_a = dbPath.split('/').pop()) === null || _a === void 0 ? void 0 : _a.replace('.db', '')) || 'default';
-                    const db = await this.getDatabase(dbName);
-                    const results = this.executeQuery(db, sqlQuery);
-                    callback(results);
-                }
-                catch (error) {
-                    callback([]);
-                }
-            },
-            createDatabase: async (dbPath, callback) => {
-                var _a;
-                try {
-                    const dbName = ((_a = dbPath.split('/').pop()) === null || _a === void 0 ? void 0 : _a.replace('.db', '')) || 'default';
-                    await this.getDatabase(dbName);
-                    callback();
-                }
-                catch (error) {
-                    callback();
-                }
-            },
-            getDBFilePath: async (options, callback) => {
-                callback(`sqljs://${options.name}`);
-            },
-            saveWebDB: async (options, callback, errorCallback) => {
-                try {
-                    const db = await this.getDatabase(options.dbName);
-                    if (Array.isArray(options.data)) {
-                        for (const item of options.data) {
-                            if (item.query && item.params) {
-                                db.run(item.query, item.params);
-                            }
-                        }
-                    }
-                    callback({ success: true });
-                }
-                catch (error) {
-                    errorCallback(error instanceof Error ? error.message : String(error));
-                }
-            },
-            exportWebDB: async (options, callback, errorCallback) => {
-                try {
-                    const db = await this.getDatabase(options.dbName);
-                    const tables = this.executeQuery(db, "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'");
-                    callback({ success: true, tables: tables.map(t => t.name) });
-                }
-                catch (error) {
-                    errorCallback(error instanceof Error ? error.message : String(error));
-                }
-            },
-            deleteUserData: async (options, callback, errorCallback) => {
-                try {
-                    const db = await this.getDatabase(options.dbName);
-                    const query = options.userId ? 'DELETE FROM user_data WHERE user_id = ?' : 'DELETE FROM user_data';
-                    const params = options.userId ? [options.userId] : [];
-                    db.run(query, params);
-                    callback();
-                }
-                catch (error) {
-                    errorCallback(error instanceof Error ? error.message : String(error));
-                }
-            }
-        };
-    }
-}