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

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

@@ -5,6 +5,7 @@ import { IDatabaseAdapter } from "../types";
  */
 export declare class DatabaseWeb {
     private databases;
+    private txDepths;
     private defaultLocation;
     private getDatabase;
     private persistDatabase;

package/dist/database/services/DatabaseWeb.js

@@ -46,6 +46,7 @@ function getSqlJs() {
 export class DatabaseWeb {
     constructor() {
         this.databases = new Map();
+        this.txDepths = new Map();
         this.defaultLocation = "default";
     }
     async getDatabase(name, location) {
@@ -106,7 +107,94 @@ export class DatabaseWeb {
                     const dbName = (options.dbName || options.userId || "default");
                     const params = options.params || options.args || [];
                     const db = await this.getDatabase(dbName);
-                    const trimmedQuery = options.query.trim();
+                    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 {
+                                db.run("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 {
+                            this.txDepths.set(dbName, currentDepth + 1);
+                            try {
+                                db.run(`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 {
+                                db.run(`RELEASE SAVEPOINT trans_sp_${newDepth};`);
+                            }
+                            catch (spErr) { }
+                        }
+                        else if (currentDepth === 1) {
+                            this.txDepths.set(dbName, 0);
+                            try {
+                                db.run("COMMIT;");
+                            }
+                            catch (txErr) {
+                                const msg = (txErr && (txErr.message || String(txErr))) || "";
+                                if (!msg.includes("no transaction is active") && !msg.includes("cannot commit")) {
+                                    throw txErr;
+                                }
+                            }
+                            this.persistDatabase(dbName);
+                        }
+                        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 {
+                                db.run(`ROLLBACK TO SAVEPOINT trans_sp_${newDepth};`);
+                            }
+                            catch (spErr) { }
+                            try {
+                                db.run(`RELEASE SAVEPOINT trans_sp_${newDepth};`);
+                            }
+                            catch (spErr) { }
+                        }
+                        else if (currentDepth === 1) {
+                            this.txDepths.set(dbName, 0);
+                            try {
+                                db.run("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 isSelect = /^SELECT\b/i.test(trimmedQuery);
                     let resultToReturn = [];
                     if (isSelect) {
@@ -138,11 +226,29 @@ export class DatabaseWeb {
                         catch (e) { }
                         resultToReturn.insertId = insertId;
                         resultToReturn.rowsAffected = rowsAffected;
-                        this.persistDatabase(dbName);
+                        // Only persist if not in an uncommitted transaction
+                        const currentDepth = this.txDepths.get(dbName) || 0;
+                        if (currentDepth === 0) {
+                            this.persistDatabase(dbName);
+                        }
                     }
                     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));
                 }
             },
@@ -173,6 +279,7 @@ export class DatabaseWeb {
                     callback(resultToReturn);
                 }
                 catch (error) {
+                    console.error("[DatabaseWeb] executeStatementOnPath error:", error);
                     callback([]);
                 }
             },
@@ -190,6 +297,7 @@ export class DatabaseWeb {
                     callback(resultToReturn);
                 }
                 catch (error) {
+                    console.error("[DatabaseWeb] selectFromPath error:", error);
                     callback([]);
                 }
             },
@@ -201,32 +309,35 @@ export class DatabaseWeb {
                     callback();
                 }
                 catch (error) {
+                    console.error("[DatabaseWeb] createDatabase error:", error);
                     callback();
                 }
             },
-            getDBFilePath: async (options, callback) => {
-                callback(`${options.name || options.userId || "default"}.db`);
+            getDBFilePath: (options, callback) => {
+                callback(options.name);
             },
-            saveWebDB: async (options, callback, errorCallback) => {
+            saveWebDB: (options, callback, errorCallback) => {
                 try {
-                    const dbName = options.dbName || options.userId || "default";
-                    const db = await this.getDatabase(dbName);
-                    const data = db.export();
-                    if (typeof localStorage !== "undefined") {
-                        localStorage.setItem(`__sqlite_${dbName}`, JSON.stringify(Array.from(data)));
-                    }
-                    callback({ success: true });
+                    const dbName = (options.dbName || "default");
+                    this.persistDatabase(dbName);
+                    callback({ success: true, message: "Database saved to localStorage" });
                 }
                 catch (error) {
                     errorCallback(error instanceof Error ? error.message : String(error));
                 }
             },
-            exportWebDB: async (options, callback, errorCallback) => {
+            exportWebDB: (options, callback, errorCallback) => {
                 try {
-                    const dbName = options.dbName || options.userId || "default";
-                    const db = await this.getDatabase(dbName);
-                    const data = db.export();
-                    callback({ success: true, data: Array.from(data) });
+                    const dbName = (options.dbName || "default");
+                    const dbKey = `${dbName}_${this.defaultLocation}`;
+                    const db = this.databases.get(dbKey);
+                    if (db) {
+                        const data = db.export();
+                        callback({ success: true, data: Array.from(data) });
+                    }
+                    else {
+                        errorCallback("Database not found");
+                    }
                 }
                 catch (error) {
                     errorCallback(error instanceof Error ? error.message : String(error));
@@ -234,22 +345,10 @@ export class DatabaseWeb {
             },
             deleteUserData: async (options, callback, errorCallback) => {
                 try {
-                    const dbName = options.dbName || options.userId;
-                    if (dbName) {
-                        const dbKey = `${dbName}_${this.defaultLocation}`;
-                        if (this.databases.has(dbKey)) {
-                            const db = this.databases.get(dbKey);
-                            try {
-                                db === null || db === void 0 ? void 0 : db.close();
-                            }
-                            catch (e) { }
-                            this.databases.delete(dbKey);
-                        }
-                        if (typeof localStorage !== "undefined") {
-                            localStorage.removeItem(`__sqlite_${dbName}`);
-                            localStorage.removeItem(`__unvired_db_${dbName}`);
-                        }
-                    }
+                    const dbName = (options.dbName || options.userId || "default");
+                    const db = await this.getDatabase(dbName);
+                    db.run("DELETE FROM user_data;");
+                    this.persistDatabase(dbName);
                     callback();
                 }
                 catch (error) {
@@ -257,7 +356,12 @@ export class DatabaseWeb {
                 }
             },
             getEncryptionKey: (options, successCallback, errorCallback) => {
-                successCallback("");
+                try {
+                    successCallback("unvired_default_key");
+                }
+                catch (error) {
+                    errorCallback();
+                }
             },
         };
     }

package/dist/device-info/services/DeviceInfoNative.js

@@ -7,6 +7,20 @@ try {
 catch (e) {
     RNDeviceInfo = null;
 }
+let ExpoDevice = null;
+let ExpoApplication = null;
+try {
+    ExpoDevice = require("expo-device");
+}
+catch (e) {
+    ExpoDevice = null;
+}
+try {
+    ExpoApplication = require("expo-application");
+}
+catch (e) {
+    ExpoApplication = null;
+}
 export class DeviceInfoNative {
     getDeviceInfo() {
         try {
@@ -24,6 +38,21 @@ export class DeviceInfoNative {
                     deviceType: RNDeviceInfo.getDeviceType ? RNDeviceInfo.getDeviceType() : "Handset",
                 };
             }
+            if (ExpoDevice || ExpoApplication) {
+                const isTablet = (ExpoDevice === null || ExpoDevice === void 0 ? void 0 : ExpoDevice.deviceType) === 2;
+                return {
+                    platform: Platform.OS,
+                    model: (ExpoDevice === null || ExpoDevice === void 0 ? void 0 : ExpoDevice.modelName) || "Unknown",
+                    version: Platform.Version ? Platform.Version.toString() : "1.0",
+                    isMobile: Platform.OS === "ios" || Platform.OS === "android",
+                    manufacturer: (ExpoDevice === null || ExpoDevice === void 0 ? void 0 : ExpoDevice.manufacturer) || "Unknown",
+                    uuid: (ExpoApplication === null || ExpoApplication === void 0 ? void 0 : ExpoApplication.getAndroidId) ? ExpoApplication.getAndroidId() : ((ExpoDevice === null || ExpoDevice === void 0 ? void 0 : ExpoDevice.osBuildId) || "default-uuid"),
+                    deviceId: (ExpoDevice === null || ExpoDevice === void 0 ? void 0 : ExpoDevice.osBuildId) || (ExpoDevice === null || ExpoDevice === void 0 ? void 0 : ExpoDevice.modelName) || "default-id",
+                    deviceName: (ExpoDevice === null || ExpoDevice === void 0 ? void 0 : ExpoDevice.deviceName) || "Device",
+                    brand: (ExpoDevice === null || ExpoDevice === void 0 ? void 0 : ExpoDevice.brand) || "Unknown",
+                    deviceType: isTablet ? "Tablet" : "Handset",
+                };
+            }
         }
         catch (error) {
             console.warn("Error getting native device info:", error);
@@ -58,7 +87,13 @@ export class DeviceInfoNative {
     }
     async isTablet() {
         try {
-            return RNDeviceInfo && RNDeviceInfo.isTablet ? await RNDeviceInfo.isTablet() : false;
+            if (RNDeviceInfo && RNDeviceInfo.isTablet) {
+                return await RNDeviceInfo.isTablet();
+            }
+            if (ExpoDevice) {
+                return ExpoDevice.deviceType === 2; // Expo DeviceType.TABLET === 2
+            }
+            return false;
         }
         catch (error) {
             return false;
@@ -66,7 +101,13 @@ export class DeviceInfoNative {
     }
     async getAppVersion() {
         try {
-            return RNDeviceInfo && RNDeviceInfo.getVersion ? await RNDeviceInfo.getVersion() : "1.0.0";
+            if (RNDeviceInfo && RNDeviceInfo.getVersion) {
+                return await RNDeviceInfo.getVersion();
+            }
+            if (ExpoApplication && ExpoApplication.nativeApplicationVersion) {
+                return ExpoApplication.nativeApplicationVersion;
+            }
+            return "1.0.0";
         }
         catch (error) {
             return "1.0.0";
@@ -74,7 +115,13 @@ export class DeviceInfoNative {
     }
     async getBuildNumber() {
         try {
-            return RNDeviceInfo && RNDeviceInfo.getBuildNumber ? await RNDeviceInfo.getBuildNumber() : "1";
+            if (RNDeviceInfo && RNDeviceInfo.getBuildNumber) {
+                return await RNDeviceInfo.getBuildNumber();
+            }
+            if (ExpoApplication && ExpoApplication.nativeBuildVersion) {
+                return String(ExpoApplication.nativeBuildVersion);
+            }
+            return "1";
         }
         catch (error) {
             return "1";

package/dist/file-system/FileSystem.d.ts

@@ -41,11 +41,20 @@ export interface IFileSystem {
 }
 /**
  * FileSystem class
- * Handles file system operations for React Native
- * - iOS/Android/Windows: Uses react-native-fs
- * - Web: Limited functionality (not supported)
+ * Handles file system operations for React Native & Expo
+ * - iOS/Android CLI: Uses react-native-fs
+ * - Expo: Uses expo-file-system
+ * - Web: Limited functionality
  */
 export declare class FileSystem {
+    /**
+     * Manually override the active file system adapter
+     */
+    static setFileSystemAdapter(adapter: IFileSystem): void;
+    /**
+     * Get the currently active file system adapter
+     */
+    static getFileSystemAdapter(): IFileSystem;
     /**
      * Get document directory path
      */

package/dist/file-system/FileSystem.js

@@ -1,15 +1,42 @@
 import { Platform } from 'react-native';
 import { FileSystemNative } from './services/FileSystemNative';
+import { FileSystemExpo } from './services/FileSystemExpo';
 import { FileSystemWeb } from './services/FileSystemWeb';
-// Select file system implementation based on platform
-const fsImpl = Platform.OS === 'web' ? new FileSystemWeb() : new FileSystemNative();
+function resolveFileSystemImpl() {
+    if (Platform.OS === 'web') {
+        return new FileSystemWeb();
+    }
+    if (FileSystemNative.isAvailable()) {
+        return new FileSystemNative();
+    }
+    if (FileSystemExpo.isAvailable()) {
+        return new FileSystemExpo();
+    }
+    // Default fallback
+    return new FileSystemExpo();
+}
+// Select file system implementation based on platform and available modules
+let fsImpl = resolveFileSystemImpl();
 /**
  * FileSystem class
- * Handles file system operations for React Native
- * - iOS/Android/Windows: Uses react-native-fs
- * - Web: Limited functionality (not supported)
+ * Handles file system operations for React Native & Expo
+ * - iOS/Android CLI: Uses react-native-fs
+ * - Expo: Uses expo-file-system
+ * - Web: Limited functionality
  */
 export class FileSystem {
+    /**
+     * Manually override the active file system adapter
+     */
+    static setFileSystemAdapter(adapter) {
+        fsImpl = adapter;
+    }
+    /**
+     * Get the currently active file system adapter
+     */
+    static getFileSystemAdapter() {
+        return fsImpl;
+    }
     /**
      * Get document directory path
      */
@@ -33,7 +60,8 @@ export class FileSystem {
      */
     static async getFolderBasedOnUserId(userId) {
         try {
-            return await fsImpl.getFolderBasedOnUserId(userId);
+            const folder = await fsImpl.getFolderBasedOnUserId(userId);
+            return folder.endsWith('/') ? folder : `${folder}/`;
         }
         catch (error) {
             console.error('Error getting user folder:', error);

package/dist/file-system/index.d.ts

@@ -1,3 +1,6 @@
 export { FileSystem } from './FileSystem';
-export type { IFileEntry, IDirectoryReader } from './FileSystem';
+export { FileSystemNative } from './services/FileSystemNative';
+export { FileSystemExpo } from './services/FileSystemExpo';
+export { FileSystemWeb } from './services/FileSystemWeb';
+export type { IFileEntry, IDirectoryReader, IFileSystem, FileSystemEncoding } from './FileSystem';
 export { default } from './FileSystem';

package/dist/file-system/index.js

@@ -1,3 +1,6 @@
 // File System module exports
 export { FileSystem } from './FileSystem';
+export { FileSystemNative } from './services/FileSystemNative';
+export { FileSystemExpo } from './services/FileSystemExpo';
+export { FileSystemWeb } from './services/FileSystemWeb';
 export { default } from './FileSystem';

package/dist/file-system/services/FileSystemExpo.d.ts

@@ -0,0 +1,22 @@
+import type { IFileEntry, IFileSystem, FileSystemEncoding } from '../FileSystem';
+/**
+ * FileSystem implementation for Expo using expo-file-system
+ */
+export declare class FileSystemExpo implements IFileSystem {
+    static isAvailable(): boolean;
+    private normalizeEncoding;
+    private getDocDir;
+    getDocumentDirectory(): string;
+    resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;
+    getFolderBasedOnUserId(userId: string): Promise<string>;
+    deleteUserFolder(userId: string): Promise<void>;
+    createDirectory(path: string): Promise<void>;
+    readFile(path: string, encoding?: FileSystemEncoding): Promise<string>;
+    writeFile(path: string, content: string, encoding?: FileSystemEncoding): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<any>;
+    readDir(path: string): Promise<any[]>;
+    copyFile(source: string, destination: string): Promise<void>;
+    moveFile(source: string, destination: string): Promise<void>;
+}