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

package/dist/database/DatabaseManager.js

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

package/dist/database/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Database module exports
+ */
+export { DatabaseManager } from './DatabaseManager';
+export { Database, createDatabase } from './Database';
+export type { IDatabaseAdapter, DatabaseOptions, ExecuteOptions, SaveWebDBOptions, ExportWebDBOptions, DeleteUserDataOptions, SuccessCallback, ErrorCallback, ResultCallback, SQLResultSet, SQLTransaction, SQLiteDatabase } from './types';

package/dist/database/index.js

@@ -0,0 +1,5 @@
+/**
+ * Database module exports
+ */
+export { DatabaseManager } from './DatabaseManager';
+export { Database, createDatabase } from './Database';

package/dist/database/types.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Database types and interfaces for the Unvired SDK
+ */
+export interface DatabaseOptions {
+    name: string;
+    location?: string;
+}
+export interface ExecuteOptions {
+    dbName: string;
+    query: string;
+    params?: any[];
+}
+export interface SaveWebDBOptions {
+    dbName: string;
+    data: any;
+}
+export interface ExportWebDBOptions {
+    dbName: string;
+}
+export interface DeleteUserDataOptions {
+    dbName: string;
+    userId?: string;
+}
+export type SuccessCallback<T = any> = (result: T) => void;
+export type ErrorCallback = (error: Error | string) => void;
+export type ResultCallback<T = any> = (result: T) => void;
+/**
+ * Database adapter interface
+ */
+export interface IDatabaseAdapter {
+    /**
+     * Create a new database
+     */
+    create(options: DatabaseOptions, successCallback: SuccessCallback, errorCallback: ErrorCallback): void;
+    /**
+     * Execute a SQL statement
+     */
+    execute(options: ExecuteOptions, successCallback: SuccessCallback<any[]>, errorCallback: ErrorCallback): void;
+    /**
+     * Execute a SQL statement on a specific database path
+     */
+    executeStatementOnPath(dbPath: string, sqlQuery: string, callback: ResultCallback<any[]>): void;
+    /**
+     * Execute a SELECT query on a specific database path
+     */
+    selectFromPath(dbPath: string, sqlQuery: string, callback: ResultCallback<any[]>): void;
+    /**
+     * Create a database at a specific path
+     */
+    createDatabase(dbPath: string, callback: ResultCallback<void>): void;
+    /**
+     * Get the file path of a database
+     */
+    getDBFilePath(options: DatabaseOptions, callback: ResultCallback<string>): void;
+    /**
+     * Save web database data
+     */
+    saveWebDB(options: SaveWebDBOptions, callback: ResultCallback<any>, errorCallback: ErrorCallback): void;
+    /**
+     * Export web database
+     */
+    exportWebDB(options: ExportWebDBOptions, callback: ResultCallback<any>, errorCallback: ErrorCallback): void;
+    /**
+     * Delete user data from database
+     */
+    deleteUserData(options: DeleteUserDataOptions, callback: ResultCallback<void>, errorCallback: ErrorCallback): void;
+}
+/**
+ * SQL result set interface
+ */
+export interface SQLResultSet {
+    insertId?: number;
+    rowsAffected: number;
+    rows: {
+        length: number;
+        item: (index: number) => any;
+        raw: () => any[];
+    };
+}
+/**
+ * Transaction interface
+ */
+export interface SQLTransaction {
+    executeSql(sqlStatement: string, args?: any[], callback?: (transaction: SQLTransaction, resultSet: SQLResultSet) => void, errorCallback?: (transaction: SQLTransaction, error: Error) => boolean): void;
+}
+/**
+ * Database connection interface
+ */
+export interface SQLiteDatabase {
+    transaction(callback: (transaction: SQLTransaction) => void, errorCallback?: (error: Error) => void, successCallback?: () => void): void;
+    readTransaction(callback: (transaction: SQLTransaction) => void, errorCallback?: (error: Error) => void, successCallback?: () => void): void;
+    executeSql(statement: string, params?: any[], success?: (results: any) => void, error?: (error: Error) => void): void;
+    close(success?: () => void, error?: (error: Error) => void): void;
+}

package/dist/database/types.js

@@ -0,0 +1,4 @@
+/**
+ * Database types and interfaces for the Unvired SDK
+ */
+export {};

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

@@ -0,0 +1,39 @@
+import { IDeviceInfo } from './DeviceInfo.types';
+/**
+ * Base Device Information Class
+ * Handles device information retrieval for React Native
+ */
+export declare class BaseDeviceInfo {
+    private static cachedDeviceInfo;
+    /**
+     * Get comprehensive device information (async)
+     * Call this once during app initialization to populate cache
+     */
+    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;
+    /**
+     * Get platform name
+     */
+    static getPlatform(): string;
+    /**
+     * Get frontend type
+     */
+    static getFrontendType(): string;
+    /**
+     * Check if device is a tablet
+     */
+    static isTablet(): Promise<boolean>;
+    /**
+     * Get app version
+     */
+    static getAppVersion(): Promise<string>;
+    /**
+     * Get build number
+     */
+    static getBuildNumber(): Promise<string>;
+}

package/dist/device-info/BaseDeviceInfo.js

@@ -0,0 +1,116 @@
+// BaseDeviceInfo.ts
+// Base device information implementation
+import { Platform } from 'react-native';
+import DeviceInfo from 'react-native-device-info';
+/**
+ * Base Device Information Class
+ * Handles device information retrieval for React Native
+ */
+export class BaseDeviceInfo {
+    /**
+     * Get comprehensive device information (async)
+     * Call this once during app initialization to populate cache
+     */
+    static async getDeviceInfo() {
+        if (this.cachedDeviceInfo) {
+            return this.cachedDeviceInfo;
+        }
+        try {
+            const deviceInfo = {
+                platform: Platform.OS,
+                model: await DeviceInfo.getModel(),
+                version: Platform.Version.toString(),
+                isMobile: Platform.OS === 'ios' || Platform.OS === 'android',
+                manufacturer: await DeviceInfo.getManufacturer(),
+                uuid: await DeviceInfo.getUniqueId(),
+            };
+            this.cachedDeviceInfo = deviceInfo;
+            return deviceInfo;
+        }
+        catch (error) {
+            console.error('Error getting device info:', error);
+            const fallback = {
+                platform: Platform.OS,
+                model: 'Unknown',
+                version: Platform.Version.toString(),
+                isMobile: Platform.OS === 'ios' || Platform.OS === 'android',
+            };
+            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
+     */
+    static getPlatform() {
+        return Platform.OS;
+    }
+    /**
+     * Get frontend type
+     */
+    static getFrontendType() {
+        if (Platform.OS === 'ios') {
+            return 'APPLE_PHONE';
+        }
+        else if (Platform.OS === 'android') {
+            return 'ANDROID_PHONE';
+        }
+        else if (Platform.OS === 'windows') {
+            return 'WINDOWS_PHONE';
+        }
+        else {
+            return 'UNKNOWN';
+        }
+    }
+    /**
+     * Check if device is a tablet
+     */
+    static async isTablet() {
+        try {
+            return await DeviceInfo.isTablet();
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Get app version
+     */
+    static async getAppVersion() {
+        try {
+            return await DeviceInfo.getVersion();
+        }
+        catch (error) {
+            return '1.0.0';
+        }
+    }
+    /**
+     * Get build number
+     */
+    static async getBuildNumber() {
+        try {
+            return await DeviceInfo.getBuildNumber();
+        }
+        catch (error) {
+            return '1';
+        }
+    }
+}
+BaseDeviceInfo.cachedDeviceInfo = null;

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

@@ -0,0 +1,9 @@
+import { BaseDeviceInfo } from './BaseDeviceInfo';
+/**
+ * DeviceInfo class
+ * Extends BaseDeviceInfo
+ */
+export declare class DeviceInfo extends BaseDeviceInfo {
+}
+export type { IDeviceInfo } from './DeviceInfo.types';
+export default DeviceInfo;

package/dist/device-info/DeviceInfo.js

@@ -0,0 +1,11 @@
+// DeviceInfo.ts
+// Main device info export
+import { BaseDeviceInfo } from './BaseDeviceInfo';
+/**
+ * DeviceInfo class
+ * Extends BaseDeviceInfo
+ */
+export class DeviceInfo extends BaseDeviceInfo {
+}
+// Default export
+export default DeviceInfo;

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

@@ -0,0 +1,11 @@
+/**
+ * Device information interface
+ */
+export interface IDeviceInfo {
+    platform: string;
+    model: string;
+    version: string;
+    isMobile: boolean;
+    manufacturer?: string;
+    uuid?: string;
+}

package/dist/device-info/DeviceInfo.types.js

@@ -0,0 +1,3 @@
+// DeviceInfo.types.ts
+// Type definitions for device info module
+export {};

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

@@ -0,0 +1,3 @@
+export { DeviceInfo } from './DeviceInfo';
+export type { IDeviceInfo } from './DeviceInfo.types';
+export { default } from './DeviceInfo';

package/dist/device-info/index.js

@@ -0,0 +1,3 @@
+// Device Info module exports
+export { DeviceInfo } from './DeviceInfo';
+export { default } from './DeviceInfo';