@unvired/react-native-unvired-sdk 0.0.25 → 0.0.27

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0025
+R-0.000.0027

package/dist/database/services/DatabaseNative.js

@@ -31,7 +31,7 @@ export class DatabaseNative {
                 try {
                     const db = this.getDatabase(options.dbName);
                     // FIX: Await the result properly
-                    const res = await db.execute(options.query, options.params);
+                    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;

package/dist/device-info/BaseDeviceInfo.d.ts

@@ -6,16 +6,10 @@ import { IDeviceInfo } from './DeviceInfo.types';
 export declare class BaseDeviceInfo {
     private static cachedDeviceInfo;
     /**
-     * Get comprehensive device information (async)
-     * Call this once during app initialization to populate cache
+     * Get comprehensive device information synchronously
+     * Uses synchronous methods from react-native-device-info
      */
-    static getDeviceInfo(): Promise<IDeviceInfo>;
-    /**
-     * Get device information synchronously (returns cached data)
-     * Returns loading state if not yet initialized
-     * Call getDeviceInfo() first to populate cache
-     */
-    static getDeviceInfoSync(): IDeviceInfo;
+    static getDeviceInfo(): IDeviceInfo;
     /**
      * Get platform name
      */

package/dist/device-info/BaseDeviceInfo.js

@@ -8,54 +8,47 @@ import DeviceInfo from 'react-native-device-info';
  */
 export class BaseDeviceInfo {
     /**
-     * Get comprehensive device information (async)
-     * Call this once during app initialization to populate cache
+     * Get comprehensive device information synchronously
+     * Uses synchronous methods from react-native-device-info
      */
-    static async getDeviceInfo() {
+    static getDeviceInfo() {
         if (this.cachedDeviceInfo) {
             return this.cachedDeviceInfo;
         }
         try {
+            // Use synchronous methods from react-native-device-info
             const deviceInfo = {
                 platform: Platform.OS,
-                model: await DeviceInfo.getModel(),
+                model: DeviceInfo.getModel(),
                 version: Platform.Version.toString(),
                 isMobile: Platform.OS === 'ios' || Platform.OS === 'android',
-                manufacturer: await DeviceInfo.getManufacturer(),
-                uuid: await DeviceInfo.getUniqueId(),
+                manufacturer: DeviceInfo.getManufacturerSync(),
+                uuid: DeviceInfo.getUniqueIdSync(),
+                deviceId: DeviceInfo.getUniqueIdSync(),
+                deviceName: DeviceInfo.getDeviceNameSync(),
+                brand: DeviceInfo.getBrand(),
+                deviceType: DeviceInfo.getDeviceType(),
             };
             this.cachedDeviceInfo = deviceInfo;
             return deviceInfo;
         }
         catch (error) {
             console.error('Error getting device info:', error);
+            // Return fallback with synchronous Platform data
             const fallback = {
                 platform: Platform.OS,
                 model: 'Unknown',
                 version: Platform.Version.toString(),
                 isMobile: Platform.OS === 'ios' || Platform.OS === 'android',
+                deviceId: 'N/A',
+                deviceName: 'N/A',
+                brand: 'N/A',
+                deviceType: 'N/A',
             };
             this.cachedDeviceInfo = fallback;
             return fallback;
         }
     }
-    /**
-     * Get device information synchronously (returns cached data)
-     * Returns loading state if not yet initialized
-     * Call getDeviceInfo() first to populate cache
-     */
-    static getDeviceInfoSync() {
-        if (this.cachedDeviceInfo) {
-            return this.cachedDeviceInfo;
-        }
-        // Return immediate fallback while async initialization happens
-        return {
-            platform: Platform.OS,
-            model: 'Loading...',
-            version: Platform.Version.toString(),
-            isMobile: Platform.OS === 'ios' || Platform.OS === 'android',
-        };
-    }
     /**
      * Get platform name
      */

package/dist/device-info/DeviceInfo.types.d.ts

@@ -8,4 +8,8 @@ export interface IDeviceInfo {
     isMobile: boolean;
     manufacturer?: string;
     uuid?: string;
+    deviceId?: string;
+    deviceName?: string;
+    brand?: string;
+    deviceType?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unvired/react-native-unvired-sdk",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "description": "Unvired SDK for React Native with logging, database, notifications, and file system support",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",

package/test-app/filepath.ts

@@ -0,0 +1,107 @@
+import UnviredWrapper from '@unvired/react-native-wrapper-sdk';
+
+const wrapper = new UnviredWrapper();
+const fileServiceRaw = wrapper.file();
+
+// Helper to convert ArrayBuffer to string (Native JS - No Buffer Dependency)
+function arrayBufferToString(buffer: ArrayBuffer): string {
+    // Handling small to medium files. For very large files, chunking is needed to avoid stack overflow.
+    return String.fromCharCode.apply(null, new Uint8Array(buffer) as any);
+}
+
+class SDKFileService {
+
+    // Delegate standard methods
+    getDocumentDirectoryPath() {
+        return fileServiceRaw.getDocumentDirectory();
+    }
+
+    async createFile(fileName: string, content: string): Promise<string> {
+        const dir = fileServiceRaw.getDocumentDirectory();
+
+        // Ensure dir ends with slash
+        const path = (dir.endsWith('/') ? dir : dir + '/') + fileName;
+
+        // FIX: React Native Blob implementation has issues with direct ArrayBuffer views in some versions.
+        // Passing string directly to writeExternalFile allows the underlying Blob([content]) to work 
+        // because Blob([string]) is supported.
+        const data = content;
+
+        console.log(`[SDKFileService] Creating file ${fileName} at ${path}`);
+        await fileServiceRaw.writeExternalFile(dir, fileName, data as any);
+        return path;
+    }
+
+    async readFile(fileName: string): Promise<string> {
+        let path = fileName;
+        // If not absolute path, prepend doc dir
+        if (!fileName.startsWith('/') && !fileName.startsWith('file://')) {
+            const dir = fileServiceRaw.getDocumentDirectory();
+            path = (dir.endsWith('/') ? dir : dir + '/') + fileName;
+        }
+
+        // Cleaning file:// prefix if present
+        if (path.startsWith('file://')) {
+            path = path.replace('file://', '');
+        }
+
+        console.log(`[SDKFileService] Reading file: ${path}`);
+        const data = await fileServiceRaw.readExternalFile(path);
+        return arrayBufferToString(data);
+    }
+
+    async deleteFile(fileName: string): Promise<void> {
+        let path = fileName;
+        if (!fileName.startsWith('/') && !fileName.startsWith('file://')) {
+            const dir = fileServiceRaw.getDocumentDirectory();
+            path = (dir.endsWith('/') ? dir : dir + '/') + fileName;
+        }
+
+        // Cleaning file:// prefix if present
+        if (path.startsWith('file://')) {
+            path = path.replace('file://', '');
+        }
+
+        console.log(`[SDKFileService] Deleting file: ${path}`);
+        await fileServiceRaw.deleteExternalFile(path);
+    }
+
+    async listFiles(): Promise<any[]> {
+        const dir = fileServiceRaw.getDocumentDirectory();
+        console.log(`[SDKFileService] Listing files in: ${dir}`);
+
+        // Use resolveLocalFileSystemURL to get DirectoryEntry
+        let dirEntry;
+        try {
+            dirEntry = await fileServiceRaw.resolveLocalFileSystemURL(dir);
+        } catch (e) {
+            console.error('[SDKFileService] Failed to resolve directory:', e);
+            return [];
+        }
+
+        return new Promise((resolve, reject) => {
+            try {
+                const reader = dirEntry.createReader();
+                reader.readEntries((entries: any[]) => {
+                    console.log(`[SDKFileService] Found ${entries.length} entries`);
+                    const mapped = entries.map(e => ({
+                        uri: e.nativeURL || e.fullPath,
+                        name: e.name,
+                        isDirectory: e.isDirectory,
+                        size: 0,
+                        modificationTime: Date.now() / 1000
+                    }));
+                    resolve(mapped);
+                }, (err: any) => {
+                    console.error('[SDKFileService] Failed to list files (readEntries):', err);
+                    resolve([]); // Don't crash UI
+                });
+            } catch (e) {
+                console.error('[SDKFileService] Exception in listFiles:', e);
+                resolve([]);
+            }
+        });
+    }
+}
+
+export default new SDKFileService();

package/ts-core/PlatformInterface.ts

@@ -85,7 +85,7 @@ export interface ILocalStorageAdapter {
  */
 export interface PlatformInterface {
     // Device Information
-    getDeviceInfo(): Promise<IDeviceInfo>;
+    getDeviceInfo(): IDeviceInfo;
     getPlatform(): string;
     getFrontendType(): string;
     getDocumentDirectory(): string;

package/ts-core/ReactNativePlatformAdapter.ts

@@ -1,15 +1,10 @@
-import { DeviceInfo } from '../src/device-info';
-import { DatabaseManager } from '../src/database';
-import { LocalStorage } from '../src/local-storage';
-import { logger, LogLevel } from '../src/logger';
-import { PushNotification } from '../src/push-notification';
-import { FileSystem } from '../src/file-system';
+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 {
 
-    async getDeviceInfo(): Promise<IDeviceInfo> {
-        return await DeviceInfo.getDeviceInfo();
+    getDeviceInfo(): IDeviceInfo {
+        return DeviceInfo.getDeviceInfo();
     }
 
     getPlatform(): string {
@@ -43,7 +38,11 @@ export class ReactNativePlatformAdapter implements PlatformInterface {
                 DatabaseManager.getDatabaseAdapter().create({ name: options.userId }, successCallback, errorCallback);
             },
             execute: (options: any, successCallback, errorCallback) => {
-                DatabaseManager.getDatabaseAdapter().execute(options, successCallback, errorCallback);
+                DatabaseManager.getDatabaseAdapter().execute({
+                    dbName: options.userId,
+                    query: options.query,
+                    params: options.params
+                }, successCallback, errorCallback);
             },
             executeStatementOnPath: (dbPath, sqlQuery, callback) => {
                 DatabaseManager.getDatabaseAdapter().executeStatementOnPath(dbPath, sqlQuery, callback);
@@ -79,8 +78,7 @@ export class ReactNativePlatformAdapter implements PlatformInterface {
                     await pushNotification.requestPermission(options);
                 },
                 getToken: async () => {
-                    const token = await pushNotification.getToken();
-                    return token || '';
+                    return await pushNotification.getToken();
                 },
                 onTokenRefresh: (callback) => {
                     pushNotification.onTokenRefresh(callback);

package/wrapper/fileService.ts

@@ -0,0 +1,313 @@
+import { PlatformManager } from '@unvired/unvired-ts-core-sdk';
+
+export interface IDirectoryReader {
+    readEntries(successCallback: (entries: IFileEntry[]) => void, errorCallback: (error: any) => void): void;
+}
+
+export interface IFileEntry {
+    fullPath: string;
+    nativeURL: string;
+    isDirectory?: boolean;
+    remove(callback: () => void, errorCallback: (error: any) => void): void;
+    removeRecursively(callback: () => void, errorCallback: (error: any) => void): void;
+    createReader(): IDirectoryReader;
+    getDirectory?(path: string, options: { create: boolean }, callback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    getFile?(path: string, options: { create: boolean }, callback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    file?(callback: (file: File) => void, errorCallback: (error: any) => void): void;
+    createWriter?(callback: (writer: any) => void, errorCallback: (error: any) => void): void;
+}
+
+export class FileService {
+
+    getDocumentDirectory(): string {
+        // @ts-ignore
+        return PlatformManager.getInstance().getPlatformAdapter().getDocumentDirectory();
+    }
+
+    resolveLocalFileSystemURL(url: string): Promise<IFileEntry> {
+        // @ts-ignore
+        return PlatformManager.getInstance().getPlatformAdapter().resolveLocalFileSystemURL(url);
+    }
+
+    async getFolderBasedOnUserId(userId: string): Promise<string> {
+        // @ts-ignore
+        return await PlatformManager.getInstance().getPlatformAdapter().getFolderBasedOnUserId(userId);
+    }
+
+    async deleteUserFolder(userId: string): Promise<void> {
+        // @ts-ignore
+        await PlatformManager.getInstance().getPlatformAdapter().deleteUserFolder(userId);
+    }
+
+    /**
+     * Reads an external file as ArrayBuffer using IFileEntry API
+     * @param filePath Absolute path to the file
+     */
+    async readExternalFile(filePath: string): Promise<ArrayBuffer> {
+        // Get the file entry
+        const fileEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            // Use the file() method to read the file
+            if (!fileEntry.file) {
+                reject(new Error('file() method not available on entry'));
+                return;
+            }
+
+            fileEntry.file(
+                async (fileMetadata: any) => {
+                    try {
+                        // Read the file using react-native-fs
+                        const RNFS = await import('react-native-fs');
+                        const content = await RNFS.readFile(fileMetadata.path, 'utf8');
+
+                        // Convert string to ArrayBuffer
+                        const encoder = new TextEncoder();
+                        resolve(encoder.encode(content).buffer);
+                    } catch (error) {
+                        reject(error);
+                    }
+                },
+                (error: any) => {
+                    reject(error);
+                }
+            );
+        });
+    }
+
+    /**
+     * Writes data to an external file using IFileEntry API
+     * @param filePath Parent directory path
+     * @param fileName File name
+     * @param data Data to write (ArrayBuffer or string)
+     */
+    async writeExternalFile(filePath: string, fileName: string, data: ArrayBuffer | string): Promise<void> {
+        // Convert data to string if it's ArrayBuffer
+        let content: string;
+        if (data instanceof ArrayBuffer) {
+            const decoder = new TextDecoder();
+            content = decoder.decode(data);
+        } else {
+            content = data;
+        }
+
+        // Get the directory entry
+        const dirEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            // Get or create the file
+            if (!dirEntry.getFile) {
+                reject(new Error('getFile() method not available on directory entry'));
+                return;
+            }
+
+            dirEntry.getFile(
+                fileName,
+                { create: true },
+                (fileEntry: IFileEntry) => {
+                    // Create a writer
+                    if (!fileEntry.createWriter) {
+                        reject(new Error('createWriter() method not available on file entry'));
+                        return;
+                    }
+
+                    fileEntry.createWriter(
+                        (writer: any) => {
+                            writer.onwriteend = () => {
+                                resolve();
+                            };
+                            writer.onerror = (error: any) => {
+                                reject(error);
+                            };
+
+                            // Write the content
+                            writer.write(content);
+                        },
+                        (error: any) => {
+                            reject(error);
+                        }
+                    );
+                },
+                (error: any) => {
+                    reject(error);
+                }
+            );
+        });
+    }
+
+    /**
+     * Deletes an external file using IFileEntry API
+     * @param filePath Absolute path to the file
+     */
+    async deleteExternalFile(filePath: string): Promise<void> {
+        const fileEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            fileEntry.remove(
+                () => resolve(),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Checks if a file exists using IFileEntry API
+     * @param filePath Absolute path to the file
+     */
+    async fileExists(filePath: string): Promise<boolean> {
+        try {
+            await this.resolveLocalFileSystemURL(filePath);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Creates a directory
+     * @param dirPath Parent directory path
+     * @param dirName Directory name to create
+     */
+    async createDirectory(dirPath: string, dirName: string): Promise<IFileEntry> {
+        const parentEntry = await this.resolveLocalFileSystemURL(dirPath);
+
+        return new Promise((resolve, reject) => {
+            if (!parentEntry.getDirectory) {
+                reject(new Error('getDirectory() method not available on entry'));
+                return;
+            }
+
+            parentEntry.getDirectory(
+                dirName,
+                { create: true },
+                (dirEntry: IFileEntry) => resolve(dirEntry),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Lists files and directories in a directory
+     * @param dirPath Directory path to list
+     */
+    async listDirectory(dirPath: string): Promise<IFileEntry[]> {
+        const dirEntry = await this.resolveLocalFileSystemURL(dirPath);
+
+        return new Promise((resolve, reject) => {
+            const reader = dirEntry.createReader();
+            reader.readEntries(
+                (entries: IFileEntry[]) => resolve(entries),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Deletes a directory and all its contents
+     * @param dirPath Directory path to delete
+     */
+    async deleteDirectory(dirPath: string): Promise<void> {
+        const dirEntry = await this.resolveLocalFileSystemURL(dirPath);
+
+        return new Promise((resolve, reject) => {
+            dirEntry.removeRecursively(
+                () => resolve(),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Copies a file
+     * @param sourcePath Source file path
+     * @param destDir Destination directory path
+     * @param newName New file name (optional, keeps original name if not provided)
+     */
+    async copyFile(sourcePath: string, destDir: string, newName?: string): Promise<void> {
+        // Read source file
+        const content = await this.readExternalFile(sourcePath);
+
+        // Get source file name if newName not provided
+        const fileName = newName || sourcePath.split('/').pop() || 'file';
+
+        // Write to destination
+        await this.writeExternalFile(destDir, fileName, content);
+    }
+
+    /**
+     * Moves/renames a file
+     * @param sourcePath Source file path
+     * @param destDir Destination directory path
+     * @param newName New file name (optional, keeps original name if not provided)
+     */
+    async moveFile(sourcePath: string, destDir: string, newName?: string): Promise<void> {
+        // Copy file to destination
+        await this.copyFile(sourcePath, destDir, newName);
+
+        // Delete source file
+        await this.deleteExternalFile(sourcePath);
+    }
+
+    /**
+     * Gets file information (size, modification date, etc.)
+     * @param filePath File path
+     */
+    async getFileInfo(filePath: string): Promise<any> {
+        const fileEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            if (!fileEntry.file) {
+                reject(new Error('file() method not available on entry'));
+                return;
+            }
+
+            fileEntry.file(
+                (fileMetadata: any) => resolve(fileMetadata),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Appends data to an existing file
+     * @param filePath File path
+     * @param data Data to append
+     */
+    async appendToFile(filePath: string, data: ArrayBuffer | string): Promise<void> {
+        // Convert data to string if it's ArrayBuffer
+        let content: string;
+        if (data instanceof ArrayBuffer) {
+            const decoder = new TextDecoder();
+            content = decoder.decode(data);
+        } else {
+            content = data;
+        }
+
+        const fileEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            if (!fileEntry.createWriter) {
+                reject(new Error('createWriter() method not available on file entry'));
+                return;
+            }
+
+            fileEntry.createWriter(
+                (writer: any) => {
+                    writer.onwriteend = () => {
+                        resolve();
+                    };
+                    writer.onerror = (error: any) => {
+                        reject(error);
+                    };
+
+                    // Append the content
+                    writer.append(content);
+                },
+                (error: any) => {
+                    reject(error);
+                }
+            );
+        });
+    }
+
+}