@unvired/react-native-unvired-sdk 0.0.45 → 0.0.47

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0045
+R-0.000.0047

package/dist/database/DatabaseManager.d.ts

@@ -1,11 +1,20 @@
 import { IDatabaseAdapter } from "./types";
 /**
  * DatabaseManager - Manages native database operations
- * - iOS/Android/Windows: Uses @op-engineering/op-sqlite
+ * - React Native CLI: Uses @op-engineering/op-sqlite
+ * - Expo: Uses expo-sqlite
  */
 export declare class DatabaseManager {
     /**
      * Get the database adapter implementation
      */
     static getDatabaseAdapter(): IDatabaseAdapter;
+    /**
+     * Manually override the database adapter
+     */
+    static setDatabaseAdapter(adapter: {
+        getAdapter(): IDatabaseAdapter;
+    }): void;
 }
+export { DatabaseExpo } from "./services/DatabaseExpo";
+export { DatabaseNative } from "./services/DatabaseNative";

package/dist/database/DatabaseManager.js

@@ -1,8 +1,20 @@
 import { DatabaseNative } from "./services/DatabaseNative";
-const dbImpl = new DatabaseNative();
+import { DatabaseExpo } from "./services/DatabaseExpo";
+function resolveAdapter() {
+    if (DatabaseNative.isAvailable()) {
+        return new DatabaseNative();
+    }
+    if (DatabaseExpo.isAvailable()) {
+        return new DatabaseExpo();
+    }
+    // Default fallback
+    return new DatabaseNative();
+}
+let dbImpl = resolveAdapter();
 /**
  * DatabaseManager - Manages native database operations
- * - iOS/Android/Windows: Uses @op-engineering/op-sqlite
+ * - React Native CLI: Uses @op-engineering/op-sqlite
+ * - Expo: Uses expo-sqlite
  */
 export class DatabaseManager {
     /**
@@ -11,4 +23,12 @@ export class DatabaseManager {
     static getDatabaseAdapter() {
         return dbImpl.getAdapter();
     }
+    /**
+     * Manually override the database adapter
+     */
+    static setDatabaseAdapter(adapter) {
+        dbImpl = adapter;
+    }
 }
+export { DatabaseExpo } from "./services/DatabaseExpo";
+export { DatabaseNative } from "./services/DatabaseNative";

package/dist/database/DatabaseManager.web.d.ts

@@ -8,4 +8,11 @@ export declare class DatabaseManager {
      * Get the database adapter implementation
      */
     static getDatabaseAdapter(): IDatabaseAdapter;
+    /**
+     * Manually override the database adapter
+     */
+    static setDatabaseAdapter(adapter: {
+        getAdapter(): IDatabaseAdapter;
+    }): void;
 }
+export { DatabaseWeb } from "./services/DatabaseWeb";

package/dist/database/DatabaseManager.web.js

@@ -1,5 +1,5 @@
 import { DatabaseWeb } from "./services/DatabaseWeb";
-const dbImpl = new DatabaseWeb();
+let dbImpl = new DatabaseWeb();
 /**
  * DatabaseManager - Manages web database operations
  * - Web: Uses Browser/WebSQL/IndexedDB/UnviredDB via sql.js
@@ -11,4 +11,11 @@ export class DatabaseManager {
     static getDatabaseAdapter() {
         return dbImpl.getAdapter();
     }
+    /**
+     * Manually override the database adapter
+     */
+    static setDatabaseAdapter(adapter) {
+        dbImpl = adapter;
+    }
 }
+export { DatabaseWeb } from "./services/DatabaseWeb";

package/dist/database/index.d.ts

@@ -3,4 +3,7 @@
  */
 export { DatabaseManager } from './DatabaseManager';
 export { Database, createDatabase } from './Database';
+export { DatabaseNative } from './services/DatabaseNative';
+export { DatabaseExpo } from './services/DatabaseExpo';
+export { DatabaseWeb } from './services/DatabaseWeb';
 export type { IDatabaseAdapter, DatabaseOptions, ExecuteOptions, SaveWebDBOptions, ExportWebDBOptions, DeleteUserDataOptions, SuccessCallback, ErrorCallback, ResultCallback, SQLResultSet, SQLTransaction, SQLiteDatabase } from './types';

package/dist/database/index.js

@@ -3,3 +3,6 @@
  */
 export { DatabaseManager } from './DatabaseManager';
 export { Database, createDatabase } from './Database';
+export { DatabaseNative } from './services/DatabaseNative';
+export { DatabaseExpo } from './services/DatabaseExpo';
+export { DatabaseWeb } from './services/DatabaseWeb';

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

@@ -0,0 +1,14 @@
+import { IDatabaseAdapter } from "../types";
+/**
+ * DatabaseExpo - SQLite adapter for Expo environments using expo-sqlite
+ * Supports Expo SDK 50+ (openDatabaseSync / openDatabaseAsync) and legacy versions
+ */
+export declare class DatabaseExpo {
+    private databases;
+    private txDepths;
+    static isAvailable(): boolean;
+    private normalizeDbName;
+    private getDatabase;
+    private executeRaw;
+    getAdapter(): IDatabaseAdapter;
+}

package/dist/database/services/DatabaseExpo.js

@@ -0,0 +1,284 @@
+let expoSqlite = null;
+try {
+    expoSqlite = require("expo-sqlite");
+}
+catch (e) {
+    expoSqlite = null;
+}
+/**
+ * DatabaseExpo - SQLite adapter for Expo environments using expo-sqlite
+ * Supports Expo SDK 50+ (openDatabaseSync / openDatabaseAsync) and legacy versions
+ */
+export class DatabaseExpo {
+    constructor() {
+        this.databases = new Map();
+        this.txDepths = new Map();
+    }
+    static isAvailable() {
+        return (expoSqlite != null &&
+            (typeof expoSqlite.openDatabaseSync === "function" ||
+                typeof expoSqlite.openDatabaseAsync === "function" ||
+                typeof expoSqlite.openDatabase === "function"));
+    }
+    normalizeDbName(name) {
+        if (!name)
+            return "default.db";
+        return name.endsWith(".db") ? name : `${name}.db`;
+    }
+    async getDatabase(name) {
+        const dbKey = this.normalizeDbName(name);
+        if (this.databases.has(dbKey)) {
+            return this.databases.get(dbKey);
+        }
+        if (!expoSqlite) {
+            throw new Error("expo-sqlite is not installed or available");
+        }
+        let db = null;
+        if (typeof expoSqlite.openDatabaseSync === "function") {
+            db = expoSqlite.openDatabaseSync(dbKey);
+        }
+        else if (typeof expoSqlite.openDatabaseAsync === "function") {
+            db = await expoSqlite.openDatabaseAsync(dbKey);
+        }
+        else if (typeof expoSqlite.openDatabase === "function") {
+            db = expoSqlite.openDatabase(dbKey);
+        }
+        else {
+            throw new Error("Compatible expo-sqlite openDatabase method not found");
+        }
+        this.databases.set(dbKey, db);
+        return db;
+    }
+    async executeRaw(db, query, params = []) {
+        const trimmed = query.trim();
+        const isSelect = /^SELECT\b/i.test(trimmed);
+        if (typeof db.getAllAsync === "function" && isSelect) {
+            return await db.getAllAsync(query, params);
+        }
+        else if (typeof db.runAsync === "function") {
+            return await db.runAsync(query, params);
+        }
+        else if (typeof db.execAsync === "function") {
+            return await db.execAsync(query);
+        }
+        else if (typeof db.transaction === "function") {
+            return new Promise((resolve, reject) => {
+                db.transaction((tx) => {
+                    tx.executeSql(query, params, (_, res) => resolve(res), (_, err) => reject(err));
+                });
+            });
+        }
+        throw new Error("No compatible query execution method on expo-sqlite database");
+    }
+    getAdapter() {
+        return {
+            create: async (options, successCallback, errorCallback) => {
+                try {
+                    const dbName = options.name || options.userId || "default";
+                    await this.getDatabase(dbName);
+                    successCallback({ success: true, database: dbName });
+                }
+                catch (error) {
+                    errorCallback(error instanceof Error ? error.message : String(error));
+                }
+            },
+            execute: async (options, successCallback, errorCallback) => {
+                var _a, _b;
+                try {
+                    const dbName = options.dbName || options.userId || "default";
+                    const params = options.params || options.args || [];
+                    const db = await this.getDatabase(dbName);
+                    const rawQuery = options.query || "";
+                    const trimmedQuery = rawQuery.trim().replace(/;+$/, "").toUpperCase().replace(/\s+/g, " ");
+                    // Intercept transaction commands to prevent "cannot start a transaction within a transaction"
+                    if (trimmedQuery === "BEGIN" || trimmedQuery === "BEGIN TRANSACTION") {
+                        const currentDepth = this.txDepths.get(dbName) || 0;
+                        if (currentDepth === 0) {
+                            this.txDepths.set(dbName, 1);
+                            try {
+                                await this.executeRaw(db, "BEGIN TRANSACTION;");
+                            }
+                            catch (txErr) {
+                                const msg = (txErr && (txErr.message || String(txErr))) || "";
+                                if (msg.includes("within a transaction") || msg.includes("already in a transaction")) {
+                                    this.txDepths.set(dbName, currentDepth + 1);
+                                }
+                                else {
+                                    throw txErr;
+                                }
+                            }
+                        }
+                        else {
+                            // Nested transaction on the same SQLite connection: translate to SAVEPOINT
+                            this.txDepths.set(dbName, currentDepth + 1);
+                            try {
+                                await this.executeRaw(db, `SAVEPOINT trans_sp_${currentDepth};`);
+                            }
+                            catch (spErr) { }
+                        }
+                        successCallback([]);
+                        return;
+                    }
+                    if (trimmedQuery === "COMMIT" || trimmedQuery === "END" || trimmedQuery === "END TRANSACTION" || trimmedQuery === "COMMIT TRANSACTION") {
+                        const currentDepth = this.txDepths.get(dbName) || 0;
+                        if (currentDepth > 1) {
+                            const newDepth = currentDepth - 1;
+                            this.txDepths.set(dbName, newDepth);
+                            try {
+                                await this.executeRaw(db, `RELEASE SAVEPOINT trans_sp_${newDepth};`);
+                            }
+                            catch (spErr) { }
+                        }
+                        else if (currentDepth === 1) {
+                            this.txDepths.set(dbName, 0);
+                            try {
+                                await this.executeRaw(db, "COMMIT;");
+                            }
+                            catch (txErr) {
+                                const msg = (txErr && (txErr.message || String(txErr))) || "";
+                                if (!msg.includes("no transaction is active") && !msg.includes("cannot commit")) {
+                                    throw txErr;
+                                }
+                            }
+                        }
+                        successCallback([]);
+                        return;
+                    }
+                    if (trimmedQuery === "ROLLBACK" || trimmedQuery === "ROLLBACK TRANSACTION") {
+                        const currentDepth = this.txDepths.get(dbName) || 0;
+                        if (currentDepth > 1) {
+                            const newDepth = currentDepth - 1;
+                            this.txDepths.set(dbName, newDepth);
+                            try {
+                                await this.executeRaw(db, `ROLLBACK TO SAVEPOINT trans_sp_${newDepth};`);
+                            }
+                            catch (spErr) { }
+                            try {
+                                await this.executeRaw(db, `RELEASE SAVEPOINT trans_sp_${newDepth};`);
+                            }
+                            catch (spErr) { }
+                        }
+                        else if (currentDepth === 1) {
+                            this.txDepths.set(dbName, 0);
+                            try {
+                                await this.executeRaw(db, "ROLLBACK;");
+                            }
+                            catch (txErr) {
+                                const msg = (txErr && (txErr.message || String(txErr))) || "";
+                                if (!msg.includes("no transaction is active") && !msg.includes("cannot rollback")) {
+                                    throw txErr;
+                                }
+                            }
+                        }
+                        else {
+                            this.txDepths.set(dbName, 0);
+                        }
+                        successCallback([]);
+                        return;
+                    }
+                    const res = await this.executeRaw(db, options.query, params);
+                    let resultToReturn = [];
+                    if (Array.isArray(res)) {
+                        resultToReturn = res;
+                    }
+                    else if (res && typeof res === "object") {
+                        if (res.rows && typeof res.rows.length === "number") {
+                            for (let i = 0; i < res.rows.length; i++) {
+                                resultToReturn.push(res.rows.item ? res.rows.item(i) : res.rows[i]);
+                            }
+                        }
+                        if (res.lastInsertRowId !== undefined || res.insertId !== undefined) {
+                            resultToReturn.insertId = (_a = res.lastInsertRowId) !== null && _a !== void 0 ? _a : res.insertId;
+                            resultToReturn.rowsAffected = (_b = res.changes) !== null && _b !== void 0 ? _b : res.rowsAffected;
+                        }
+                    }
+                    successCallback(resultToReturn);
+                }
+                catch (error) {
+                    const msg = (error && (error.message || String(error))) || "";
+                    if (msg.includes("cannot start a transaction within a transaction")) {
+                        const dbName = options.dbName || options.userId || "default";
+                        const currentDepth = this.txDepths.get(dbName) || 0;
+                        this.txDepths.set(dbName, currentDepth + 1);
+                        successCallback([]);
+                        return;
+                    }
+                    if (msg.includes("no transaction is active") || msg.includes("cannot rollback") || msg.includes("cannot commit")) {
+                        const dbName = options.dbName || options.userId || "default";
+                        this.txDepths.set(dbName, 0);
+                        successCallback([]);
+                        return;
+                    }
+                    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 res = await this.executeRaw(db, sqlQuery);
+                    callback(Array.isArray(res) ? res : []);
+                }
+                catch (error) {
+                    callback(error instanceof Error ? error.message : String(error));
+                }
+            },
+            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 res = await this.executeRaw(db, sqlQuery);
+                    callback(Array.isArray(res) ? res : []);
+                }
+                catch (error) {
+                    callback(error instanceof Error ? error.message : String(error));
+                }
+            },
+            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(true);
+                }
+                catch (error) {
+                    callback(error instanceof Error ? error.message : String(error));
+                }
+            },
+            getDBFilePath: (options, callback) => {
+                callback(options.name);
+            },
+            saveWebDB: (options, callback, errorCallback) => {
+                errorCallback("saveWebDB is only available on web platform");
+            },
+            exportWebDB: (options, callback, errorCallback) => {
+                errorCallback("exportWebDB is only available on web platform");
+            },
+            deleteUserData: async (options, callback, errorCallback) => {
+                try {
+                    const dbName = options.dbName || options.userId || "default";
+                    const db = await this.getDatabase(dbName);
+                    const query = options.userId
+                        ? "DELETE FROM user_data WHERE user_id = ?"
+                        : "DELETE FROM user_data";
+                    const params = options.userId ? [options.userId] : [];
+                    await this.executeRaw(db, query, params);
+                    callback();
+                }
+                catch (error) {
+                    errorCallback(error instanceof Error ? error.message : String(error));
+                }
+            },
+            getEncryptionKey: (options, successCallback, errorCallback) => {
+                try {
+                    successCallback("unvired_default_key");
+                }
+                catch (error) {
+                    errorCallback();
+                }
+            },
+        };
+    }
+}

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

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

package/dist/database/services/DatabaseNative.js

@@ -1,9 +1,19 @@
-import { open } from '@op-engineering/op-sqlite';
+let opSqlite = null;
+try {
+    opSqlite = require('@op-engineering/op-sqlite');
+}
+catch (e) {
+    opSqlite = null;
+}
 export class DatabaseNative {
     constructor() {
         this.databases = new Map();
+        this.txDepths = new Map();
         this.defaultLocation = "default";
     }
+    static isAvailable() {
+        return opSqlite != null && typeof opSqlite.open === 'function';
+    }
     getDatabase(name, location) {
         const dbKey = `${name}_${location || this.defaultLocation}`;
         if (this.databases.has(dbKey)) {
@@ -12,7 +22,10 @@ export class DatabaseNative {
         if (!name) {
             throw new Error("Database name is required");
         }
-        const db = open({ name });
+        if (!DatabaseNative.isAvailable()) {
+            throw new Error("@op-engineering/op-sqlite is not installed or available");
+        }
+        const db = opSqlite.open({ name });
         this.databases.set(dbKey, db);
         return db;
     }
@@ -33,7 +46,95 @@ export class DatabaseNative {
                     const dbName = options.dbName || options.userId;
                     const params = options.params || options.args || [];
                     const db = this.getDatabase(dbName);
-                    // FIX: Await the result properly
+                    const rawQuery = options.query || "";
+                    const trimmedQuery = rawQuery.trim().replace(/;+$/, "").toUpperCase().replace(/\s+/g, " ");
+                    // Intercept transaction commands to prevent "cannot start a transaction within a transaction"
+                    if (trimmedQuery === "BEGIN" || trimmedQuery === "BEGIN TRANSACTION") {
+                        const currentDepth = this.txDepths.get(dbName) || 0;
+                        if (currentDepth === 0) {
+                            this.txDepths.set(dbName, 1);
+                            try {
+                                await db.execute("BEGIN TRANSACTION;");
+                            }
+                            catch (txErr) {
+                                const msg = (txErr && (txErr.message || String(txErr))) || "";
+                                if (msg.includes("within a transaction") || msg.includes("already in a transaction")) {
+                                    this.txDepths.set(dbName, currentDepth + 1);
+                                }
+                                else {
+                                    throw txErr;
+                                }
+                            }
+                        }
+                        else {
+                            // Nested transaction on the same SQLite connection: translate to SAVEPOINT
+                            this.txDepths.set(dbName, currentDepth + 1);
+                            try {
+                                await db.execute(`SAVEPOINT trans_sp_${currentDepth};`);
+                            }
+                            catch (spErr) { }
+                        }
+                        successCallback([]);
+                        return;
+                    }
+                    if (trimmedQuery === "COMMIT" || trimmedQuery === "END" || trimmedQuery === "END TRANSACTION" || trimmedQuery === "COMMIT TRANSACTION") {
+                        const currentDepth = this.txDepths.get(dbName) || 0;
+                        if (currentDepth > 1) {
+                            const newDepth = currentDepth - 1;
+                            this.txDepths.set(dbName, newDepth);
+                            try {
+                                await db.execute(`RELEASE SAVEPOINT trans_sp_${newDepth};`);
+                            }
+                            catch (spErr) { }
+                        }
+                        else if (currentDepth === 1) {
+                            this.txDepths.set(dbName, 0);
+                            try {
+                                await db.execute("COMMIT;");
+                            }
+                            catch (txErr) {
+                                const msg = (txErr && (txErr.message || String(txErr))) || "";
+                                if (!msg.includes("no transaction is active") && !msg.includes("cannot commit")) {
+                                    throw txErr;
+                                }
+                            }
+                        }
+                        successCallback([]);
+                        return;
+                    }
+                    if (trimmedQuery === "ROLLBACK" || trimmedQuery === "ROLLBACK TRANSACTION") {
+                        const currentDepth = this.txDepths.get(dbName) || 0;
+                        if (currentDepth > 1) {
+                            const newDepth = currentDepth - 1;
+                            this.txDepths.set(dbName, newDepth);
+                            try {
+                                await db.execute(`ROLLBACK TO SAVEPOINT trans_sp_${newDepth};`);
+                            }
+                            catch (spErr) { }
+                            try {
+                                await db.execute(`RELEASE SAVEPOINT trans_sp_${newDepth};`);
+                            }
+                            catch (spErr) { }
+                        }
+                        else if (currentDepth === 1) {
+                            this.txDepths.set(dbName, 0);
+                            try {
+                                await db.execute("ROLLBACK;");
+                            }
+                            catch (txErr) {
+                                const msg = (txErr && (txErr.message || String(txErr))) || "";
+                                if (!msg.includes("no transaction is active") && !msg.includes("cannot rollback")) {
+                                    throw txErr;
+                                }
+                            }
+                        }
+                        else {
+                            this.txDepths.set(dbName, 0);
+                        }
+                        successCallback([]);
+                        return;
+                    }
+                    // Await the result properly
                     const res = await db.execute(options.query, params);
                     let resultToReturn = [];
                     // Cast to any to avoid TS error "Property '_array' does not exist on type 'never'"
@@ -69,6 +170,20 @@ export class DatabaseNative {
                     successCallback(resultToReturn);
                 }
                 catch (error) {
+                    const msg = (error && (error.message || String(error))) || "";
+                    if (msg.includes("cannot start a transaction within a transaction")) {
+                        const dbName = options.dbName || options.userId || "default";
+                        const currentDepth = this.txDepths.get(dbName) || 0;
+                        this.txDepths.set(dbName, currentDepth + 1);
+                        successCallback([]);
+                        return;
+                    }
+                    if (msg.includes("no transaction is active") || msg.includes("cannot rollback") || msg.includes("cannot commit")) {
+                        const dbName = options.dbName || options.userId || "default";
+                        this.txDepths.set(dbName, 0);
+                        successCallback([]);
+                        return;
+                    }
                     errorCallback(error instanceof Error ? error.message : String(error));
                 }
             },
@@ -88,22 +203,11 @@ export class DatabaseNative {
                                 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([]);
+                    callback(error instanceof Error ? error.message : String(error));
                 }
             },
             selectFromPath: async (dbPath, sqlQuery, callback) => {
@@ -122,17 +226,11 @@ export class DatabaseNative {
                                 resultToReturn.push(r);
                             }
                         }
-                        else if (Array.isArray(rawRows)) {
-                            resultToReturn = rawRows;
-                        }
-                        else if (rawRows._array) {
-                            resultToReturn = rawRows._array;
-                        }
                     }
                     callback(resultToReturn);
                 }
                 catch (error) {
-                    callback([]);
+                    callback(error instanceof Error ? error.message : String(error));
                 }
             },
             createDatabase: async (dbPath, callback) => {
@@ -140,28 +238,20 @@ export class DatabaseNative {
                 try {
                     const dbName = ((_a = dbPath.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(".db", "")) || "default";
                     this.getDatabase(dbName);
-                    callback();
+                    callback(true);
                 }
                 catch (error) {
-                    callback();
+                    callback(error instanceof Error ? error.message : String(error));
                 }
             },
-            getDBFilePath: async (options, callback) => {
-                callback(`${options.name}.db`);
+            getDBFilePath: (options, callback) => {
+                callback(options.name);
             },
-            saveWebDB: async (options, callback, errorCallback) => {
-                // Not needed for native - only for web
-                callback({
-                    success: true,
-                    message: "Not applicable for native",
-                });
+            saveWebDB: (options, callback, errorCallback) => {
+                errorCallback("saveWebDB is only available on web platform");
             },
-            exportWebDB: async (options, callback, errorCallback) => {
-                // Not needed for native - only for web
-                callback({
-                    success: true,
-                    message: "Not applicable for native",
-                });
+            exportWebDB: (options, callback, errorCallback) => {
+                errorCallback("exportWebDB is only available on web platform");
             },
             deleteUserData: async (options, callback, errorCallback) => {
                 try {
@@ -179,9 +269,12 @@ export class DatabaseNative {
                 }
             },
             getEncryptionKey: (options, successCallback, errorCallback) => {
-                // Native encryption key logic can be implemented here if needed.
-                // For now, return empty or trigger errorCallback depending on support.
-                errorCallback();
+                try {
+                    successCallback("unvired_default_key");
+                }
+                catch (error) {
+                    errorCallback();
+                }
             },
         };
     }