@unvired/react-native-unvired-sdk 0.0.13 → 0.0.14

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0013
+R-0.000.0014

package/dist/database/DatabaseManager.d.ts

@@ -1,32 +1,12 @@
 import { IDatabaseAdapter } from './types';
 /**
- * DatabaseManager - Manages SQLite database operations for React Native
+ * DatabaseManager - Manages database operations across platforms
+ * - iOS/Android/Windows: Uses react-native-sqlite-storage
+ * - Web: Uses WebSQL
  */
 export declare class DatabaseManager {
-    private static databases;
-    private static defaultLocation;
-    /**
-     * Get or create a database connection
-     */
-    private static getDatabase;
-    /**
-     * Close a database connection
-     */
-    private static closeDatabase;
-    /**
-     * Convert SQLResultSet to array of objects
-     */
-    private static resultSetToArray;
     /**
      * Get the database adapter implementation
      */
     static getDatabaseAdapter(): IDatabaseAdapter;
-    /**
-     * Close all database connections
-     */
-    static closeAllDatabases(): Promise<void>;
-    /**
-     * Delete a database
-     */
-    static deleteDatabase(name: string, location?: string): Promise<void>;
 }

package/dist/database/DatabaseManager.js

@@ -1,323 +1,18 @@
-import SQLite from 'react-native-sqlite-storage';
-// Enable promise-based API and debug mode
-SQLite.enablePromise(true);
-SQLite.DEBUG(false); // Set to true for debugging
+import { Platform } from 'react-native';
+import { DatabaseNative } from './services/DatabaseNative';
+import { DatabaseWeb } from './services/DatabaseWeb';
+// Select database implementation based on platform
+const dbImpl = Platform.OS === 'web' ? new DatabaseWeb() : new DatabaseNative();
 /**
- * DatabaseManager - Manages SQLite database operations for React Native
+ * DatabaseManager - Manages database operations across platforms
+ * - iOS/Android/Windows: Uses react-native-sqlite-storage
+ * - Web: Uses WebSQL
  */
 export class DatabaseManager {
-    /**
-     * Get or create a database connection
-     */
-    static async getDatabase(name, location) {
-        const dbKey = `${name}_${location || this.defaultLocation}`;
-        if (this.databases.has(dbKey)) {
-            return this.databases.get(dbKey);
-        }
-        try {
-            const dbLocation = (location || this.defaultLocation);
-            const db = await SQLite.openDatabase({
-                name: name,
-                location: dbLocation,
-            });
-            this.databases.set(dbKey, db);
-            return db;
-        }
-        catch (error) {
-            console.error(`Error opening database ${name}:`, error);
-            throw error;
-        }
-    }
-    /**
-     * Close a database connection
-     */
-    static async closeDatabase(name, location) {
-        const dbKey = `${name}_${location || this.defaultLocation}`;
-        const db = this.databases.get(dbKey);
-        if (db) {
-            await db.close();
-            this.databases.delete(dbKey);
-        }
-    }
-    /**
-     * Convert SQLResultSet to array of objects
-     */
-    static resultSetToArray(resultSet) {
-        const results = [];
-        for (let i = 0; i < resultSet.rows.length; i++) {
-            results.push(resultSet.rows.item(i));
-        }
-        return results;
-    }
     /**
      * Get the database adapter implementation
      */
     static getDatabaseAdapter() {
-        return {
-            /**
-             * Create a new database
-             */
-            create: async (options, successCallback, errorCallback) => {
-                try {
-                    const db = await DatabaseManager.getDatabase(options.name, options.location);
-                    successCallback({ success: true, database: options.name });
-                }
-                catch (error) {
-                    const errorMsg = error instanceof Error ? error.message : String(error);
-                    console.error('Error creating database:', errorMsg);
-                    errorCallback(errorMsg);
-                }
-            },
-            /**
-             * Execute a SQL statement
-             */
-            execute: async (options, successCallback, errorCallback) => {
-                try {
-                    const db = await DatabaseManager.getDatabase(options.dbName);
-                    const results = await new Promise((resolve, reject) => {
-                        db.transaction((tx) => {
-                            tx.executeSql(options.query, options.params || [], (_, resultSet) => {
-                                const data = DatabaseManager.resultSetToArray(resultSet);
-                                resolve(data);
-                            }, (_, error) => {
-                                reject(error);
-                                return false;
-                            });
-                        });
-                    });
-                    successCallback(results);
-                }
-                catch (error) {
-                    const errorMsg = error instanceof Error ? error.message : String(error);
-                    console.error('Error executing SQL:', errorMsg);
-                    errorCallback(errorMsg);
-                }
-            },
-            /**
-             * Execute a SQL statement on a specific database path
-             */
-            executeStatementOnPath: async (dbPath, sqlQuery, callback) => {
-                var _a;
-                try {
-                    // Extract database name from path
-                    const dbName = ((_a = dbPath.split('/').pop()) === null || _a === void 0 ? void 0 : _a.replace('.db', '')) || 'default';
-                    const db = await DatabaseManager.getDatabase(dbName);
-                    const results = await new Promise((resolve, reject) => {
-                        db.transaction((tx) => {
-                            tx.executeSql(sqlQuery, [], (_, resultSet) => {
-                                const data = DatabaseManager.resultSetToArray(resultSet);
-                                resolve(data);
-                            }, (_, error) => {
-                                console.error('Error in executeStatementOnPath:', error);
-                                resolve([]);
-                                return false;
-                            });
-                        });
-                    });
-                    callback(results);
-                }
-                catch (error) {
-                    console.error('Error executing statement on path:', error);
-                    callback([]);
-                }
-            },
-            /**
-             * Execute a SELECT query on a specific database path
-             */
-            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 DatabaseManager.getDatabase(dbName);
-                    const results = await new Promise((resolve, reject) => {
-                        db.readTransaction((tx) => {
-                            tx.executeSql(sqlQuery, [], (_, resultSet) => {
-                                const data = DatabaseManager.resultSetToArray(resultSet);
-                                resolve(data);
-                            }, (_, error) => {
-                                console.error('Error in selectFromPath:', error);
-                                resolve([]);
-                                return false;
-                            });
-                        });
-                    });
-                    callback(results);
-                }
-                catch (error) {
-                    console.error('Error selecting from path:', error);
-                    callback([]);
-                }
-            },
-            /**
-             * Create a database at a specific path
-             */
-            createDatabase: async (dbPath, callback) => {
-                var _a;
-                try {
-                    const dbName = ((_a = dbPath.split('/').pop()) === null || _a === void 0 ? void 0 : _a.replace('.db', '')) || 'default';
-                    await DatabaseManager.getDatabase(dbName);
-                    callback();
-                }
-                catch (error) {
-                    console.error('Error creating database:', error);
-                    callback();
-                }
-            },
-            /**
-             * Get the file path of a database
-             */
-            getDBFilePath: async (options, callback) => {
-                try {
-                    // Return the database name with .db extension
-                    // The actual path is managed by react-native-sqlite-storage based on the location
-                    const dbPath = `${options.name}.db`;
-                    callback(dbPath);
-                }
-                catch (error) {
-                    console.error('Error getting database file path:', error);
-                    callback('');
-                }
-            },
-            /**
-             * Save web database data
-             */
-            saveWebDB: async (options, callback, errorCallback) => {
-                try {
-                    const db = await DatabaseManager.getDatabase(options.dbName);
-                    // Convert web DB data to SQLite
-                    // This is a simplified implementation - adjust based on your data structure
-                    const data = options.data;
-                    if (Array.isArray(data)) {
-                        for (const item of data) {
-                            if (item.query && item.params) {
-                                await new Promise((resolve, reject) => {
-                                    db.transaction((tx) => {
-                                        tx.executeSql(item.query, item.params, () => resolve(), (_, error) => {
-                                            reject(error);
-                                            return false;
-                                        });
-                                    });
-                                });
-                            }
-                        }
-                    }
-                    callback({ success: true, message: 'Web DB saved successfully' });
-                }
-                catch (error) {
-                    const errorMsg = error instanceof Error ? error.message : String(error);
-                    console.error('Error saving web DB:', errorMsg);
-                    errorCallback(errorMsg);
-                }
-            },
-            /**
-             * Export web database
-             */
-            exportWebDB: async (options, callback, errorCallback) => {
-                try {
-                    const db = await DatabaseManager.getDatabase(options.dbName);
-                    // Get all tables
-                    const tables = await new Promise((resolve, reject) => {
-                        db.readTransaction((tx) => {
-                            tx.executeSql("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'", [], (_, resultSet) => {
-                                const data = DatabaseManager.resultSetToArray(resultSet);
-                                resolve(data);
-                            }, (_, error) => {
-                                reject(error);
-                                return false;
-                            });
-                        });
-                    });
-                    const exportData = {};
-                    // Export data from each table
-                    for (const table of tables) {
-                        const tableName = table.name;
-                        const tableData = await new Promise((resolve, reject) => {
-                            db.readTransaction((tx) => {
-                                tx.executeSql(`SELECT * FROM ${tableName}`, [], (_, resultSet) => {
-                                    const data = DatabaseManager.resultSetToArray(resultSet);
-                                    resolve(data);
-                                }, (_, error) => {
-                                    reject(error);
-                                    return false;
-                                });
-                            });
-                        });
-                        exportData[tableName] = tableData;
-                    }
-                    callback({
-                        success: true,
-                        data: exportData,
-                        tables: tables.map(t => t.name)
-                    });
-                }
-                catch (error) {
-                    const errorMsg = error instanceof Error ? error.message : String(error);
-                    console.error('Error exporting web DB:', errorMsg);
-                    errorCallback(errorMsg);
-                }
-            },
-            /**
-             * Delete user data from database
-             */
-            deleteUserData: async (options, callback, errorCallback) => {
-                try {
-                    const db = await DatabaseManager.getDatabase(options.dbName);
-                    if (options.userId) {
-                        // Delete specific user data
-                        await new Promise((resolve, reject) => {
-                            db.transaction((tx) => {
-                                tx.executeSql('DELETE FROM user_data WHERE user_id = ?', [options.userId], () => resolve(), (_, error) => {
-                                    reject(error);
-                                    return false;
-                                });
-                            });
-                        });
-                    }
-                    else {
-                        // Delete all user data
-                        await new Promise((resolve, reject) => {
-                            db.transaction((tx) => {
-                                tx.executeSql('DELETE FROM user_data', [], () => resolve(), (_, error) => {
-                                    reject(error);
-                                    return false;
-                                });
-                            });
-                        });
-                    }
-                    callback();
-                }
-                catch (error) {
-                    const errorMsg = error instanceof Error ? error.message : String(error);
-                    console.error('Error deleting user data:', errorMsg);
-                    errorCallback(errorMsg);
-                }
-            }
-        };
-    }
-    /**
-     * Close all database connections
-     */
-    static async closeAllDatabases() {
-        const closePromises = Array.from(this.databases.values()).map(db => new Promise((resolve) => {
-            db.close(() => resolve(), () => resolve());
-        }));
-        await Promise.all(closePromises);
-        this.databases.clear();
-    }
-    /**
-     * Delete a database
-     */
-    static async deleteDatabase(name, location) {
-        try {
-            await this.closeDatabase(name, location);
-            const dbLocation = (location || this.defaultLocation);
-            await SQLite.deleteDatabase({ name, location: dbLocation });
-        }
-        catch (error) {
-            console.error(`Error deleting database ${name}:`, error);
-            throw error;
-        }
+        return dbImpl.getAdapter();
     }
 }
-DatabaseManager.databases = new Map();
-DatabaseManager.defaultLocation = 'default';

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

@@ -0,0 +1,8 @@
+import { IDatabaseAdapter } from "../types";
+export declare class DatabaseNative {
+    private databases;
+    private defaultLocation;
+    private getDatabase;
+    private resultSetToArray;
+    getAdapter(): IDatabaseAdapter;
+}

package/dist/database/services/DatabaseNative.js

@@ -0,0 +1,149 @@
+import SQLite from "react-native-sqlite-storage";
+SQLite.enablePromise(true);
+SQLite.DEBUG(false);
+export class DatabaseNative {
+    constructor() {
+        this.databases = new Map();
+        this.defaultLocation = "default";
+    }
+    async getDatabase(name, location) {
+        const dbKey = `${name}_${location || this.defaultLocation}`;
+        if (this.databases.has(dbKey)) {
+            return this.databases.get(dbKey);
+        }
+        const dbLocation = (location || this.defaultLocation);
+        const db = await SQLite.openDatabase({ name, location: dbLocation });
+        this.databases.set(dbKey, db);
+        return db;
+    }
+    resultSetToArray(resultSet) {
+        const results = [];
+        for (let i = 0; i < resultSet.rows.length; i++) {
+            results.push(resultSet.rows.item(i));
+        }
+        return results;
+    }
+    getAdapter() {
+        return {
+            create: async (options, successCallback, errorCallback) => {
+                try {
+                    await this.getDatabase(options.name, options.location);
+                    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 = await new Promise((resolve, reject) => {
+                        db.transaction((tx) => {
+                            tx.executeSql(options.query, options.params || [], (_, resultSet) => {
+                                resolve(this.resultSetToArray(resultSet));
+                            }, (_, error) => {
+                                reject(error);
+                                return false;
+                            });
+                        });
+                    });
+                    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 = await new Promise((resolve) => {
+                        db.transaction((tx) => {
+                            tx.executeSql(sqlQuery, [], (_, resultSet) => {
+                                resolve(this.resultSetToArray(resultSet));
+                            }, () => {
+                                resolve([]);
+                                return false;
+                            });
+                        });
+                    });
+                    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 = await new Promise((resolve) => {
+                        db.readTransaction((tx) => {
+                            tx.executeSql(sqlQuery, [], (_, resultSet) => {
+                                resolve(this.resultSetToArray(resultSet));
+                            }, () => {
+                                resolve([]);
+                                return false;
+                            });
+                        });
+                    });
+                    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(`${options.name}.db`);
+            },
+            saveWebDB: async (options, callback, errorCallback) => {
+                // Not needed for native - only for web
+                callback({
+                    success: true,
+                    message: "Not applicable for native",
+                });
+            },
+            exportWebDB: async (options, callback, errorCallback) => {
+                // Not needed for native - only for web
+                callback({
+                    success: true,
+                    message: "Not applicable for native",
+                });
+            },
+            deleteUserData: async (options, callback, errorCallback) => {
+                try {
+                    const db = await this.getDatabase(options.dbName);
+                    await new Promise((resolve, reject) => {
+                        db.transaction((tx) => {
+                            const query = options.userId
+                                ? "DELETE FROM user_data WHERE user_id = ?"
+                                : "DELETE FROM user_data";
+                            const params = options.userId ? [options.userId] : [];
+                            tx.executeSql(query, params, () => resolve(), (_, error) => {
+                                reject(error);
+                                return false;
+                            });
+                        });
+                    });
+                    callback();
+                }
+                catch (error) {
+                    errorCallback(error instanceof Error ? error.message : String(error));
+                }
+            },
+        };
+    }
+}

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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,138 @@
+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));
+                }
+            }
+        };
+    }
+}