@unvired/react-native-unvired-sdk 0.0.20 → 0.0.22

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0020
+R-0.000.0022

package/dist/database/DatabaseManager.d.ts

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

package/dist/database/DatabaseManager.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unvired/react-native-unvired-sdk",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "Unvired SDK for React Native with logging, database, notifications, and file system support",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
@@ -11,27 +11,15 @@
     "lint": "eslint src/",
     "format": "prettier --write \"src/**/*.{js,ts,tsx}\""
   },
-  "keywords": [
-    "react-native",
-    "unvired",
-    "sdk",
-    "mobile",
-    "logger",
-    "database",
-    "notifications",
-    "file-system"
-  ],
-  "author": "Unvired",
-  "license": "UNLICENSED",
   "peerDependencies": {
-    "react": "19.2.0",
-    "react-native": "0.83.1",
-    "react-native-fs": "^2.20.0",
-    "react-native-device-info": "^15.0.1",
     "@op-engineering/op-sqlite": "^15.2.5",
-    "react-native-zip-archive": "^7.0.2",
+    "@react-native-async-storage/async-storage": "^2.2.0",
     "@react-native-firebase/messaging": "^21.8.1",
-    "@react-native-async-storage/async-storage": "^2.2.0"
+    "react": ">=18",
+    "react-native": ">=0.73",
+    "react-native-device-info": "^15.0.1",
+    "react-native-fs": "^2.20.0",
+    "react-native-zip-archive": "^7.0.2"
   },
   "peerDependenciesMeta": {
     "@react-native-firebase/messaging": {
@@ -51,46 +39,31 @@
     },
     "react-native-fs": {
       "optional": true
-    },
-    "react": {
-      "optional": true
-    },
-    "react-native": {
-      "optional": true
     }
   },
+  "dependencies": {
+    "pako": "^2.1.0"
+  },
   "devDependencies": {
+    "@op-engineering/op-sqlite": "^15.2.5",
+    "@react-native-async-storage/async-storage": "^2.2.0",
+    "@react-native-firebase/messaging": "^21.8.1",
     "@types/pako": "^2.0.4",
-    "@types/react": ">=19.0.0",
+    "@types/react": ">=18",
     "@types/react-native": "^0.73.0",
-    "@types/sql.js": "^1.4.9",
     "eslint": "^8.0.0",
     "jest": "^29.0.0",
     "prettier": "^3.0.0",
-    "typescript": "^5.0.0",
     "react": "19.2.0",
     "react-native": "0.83.1",
-    "@react-native-firebase/app": "21.14.0"
-  },
-  "engines": {
-    "node": ">=22.0.0"
-  },
-  "dependencies": {
-    "react-native-fs": "^2.20.0",
-    "@op-engineering/op-sqlite": "^15.2.5",
-    "react-native-zip-archive": "^7.0.2",
-    "@react-native-async-storage/async-storage": "^2.2.0",
     "react-native-device-info": "^15.0.1",
-    "@react-native-firebase/messaging": "^21.8.1",
-    "pako": "^2.1.0",
-    "sql.js": "^1.10.3"
+    "react-native-fs": "^2.20.0",
+    "typescript": "^5.0.0"
   },
-  "repository": {},
-  "bugs": {},
-  "volta": {
-    "node": "25.2.1"
+  "engines": {
+    "node": ">=18"
   },
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/ts-core/ReactNativePlatformAdapter.ts

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

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

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

package/dist/database/services/DatabaseWeb.js

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