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

package/dist/PlatformAdapter.d.ts

@@ -0,0 +1,57 @@
+import { LogLevel } from './logger';
+import { IDeviceInfo } from './device-info';
+import { IFileEntry } from './file-system';
+import { IDatabaseAdapter } from './database';
+import { IPushNotificationAdapter } from './push-notification';
+export interface ILoggerAdapter {
+    logDebug(sourceClass: string, method: string, message: string): void;
+    logError(sourceClass: string, method: string, message: string): void;
+    logInfo(sourceClass: string, method: string, message: string): void;
+    setLogLevel(logLevel: LogLevel): void;
+    getLogFileURL(): Promise<string>;
+    getLogFileContent(): Promise<string>;
+    getBackupLogFileContent(): Promise<string | null>;
+    clearLogFile(): Promise<void>;
+}
+export interface IStorageAdapter {
+    getItem<T = any>(key: string): Promise<T | null>;
+    setItem(key: string, value: any): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare enum DatabaseType {
+    SQLITE = "sqlite",
+    WEBSQL = "websql"
+}
+export interface IPlatformAdapter {
+    getDeviceInfo(): IDeviceInfo;
+    getPlatform(): string;
+    getFrontendType(): string;
+    getDocumentDirectory(): string;
+    resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;
+    getFolderBasedOnUserId(userId: string): Promise<string>;
+    deleteUserFolder(userId: string): Promise<void>;
+    getDatabaseAdapter(): IDatabaseAdapter;
+    getPushNotificationAdapter(): IPushNotificationAdapter | null;
+    getLoggerAdapter(): ILoggerAdapter;
+    getStorageAdapter(): IStorageAdapter;
+}
+export declare class ReactNativePlatformAdapter implements IPlatformAdapter {
+    private deviceInfo;
+    private pushNotification;
+    constructor();
+    private initializeDeviceInfo;
+    getDeviceInfo(): IDeviceInfo;
+    getPlatform(): string;
+    getFrontendType(): string;
+    getDocumentDirectory(): string;
+    resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;
+    getFolderBasedOnUserId(userId: string): Promise<string>;
+    deleteUserFolder(userId: string): Promise<void>;
+    getDatabaseAdapter(): IDatabaseAdapter;
+    getPushNotificationAdapter(): IPushNotificationAdapter | null;
+    getLoggerAdapter(): ILoggerAdapter;
+    getStorageAdapter(): IStorageAdapter;
+}
+export declare function getPlatformAdapter(): ReactNativePlatformAdapter;
+export declare function resetPlatformAdapter(): void;

package/dist/PlatformAdapter.js

@@ -0,0 +1,116 @@
+import { logger } from './logger';
+import { DatabaseManager } from './database';
+import { LocalStorage } from './local-storage';
+import { DeviceInfo } from './device-info';
+import { FileSystem } from './file-system';
+import { PushNotification } from './push-notification';
+export var DatabaseType;
+(function (DatabaseType) {
+    DatabaseType["SQLITE"] = "sqlite";
+    DatabaseType["WEBSQL"] = "websql";
+})(DatabaseType || (DatabaseType = {}));
+export class ReactNativePlatformAdapter {
+    constructor() {
+        this.deviceInfo = null;
+        this.pushNotification = null;
+        this.initializeDeviceInfo();
+    }
+    async initializeDeviceInfo() {
+        try {
+            this.deviceInfo = await DeviceInfo.getDeviceInfo();
+        }
+        catch (error) {
+            console.error('Error initializing device info:', error);
+        }
+    }
+    getDeviceInfo() {
+        return this.deviceInfo || DeviceInfo.getDeviceInfoSync();
+    }
+    getPlatform() {
+        return DeviceInfo.getPlatform();
+    }
+    getFrontendType() {
+        return DeviceInfo.getFrontendType();
+    }
+    getDocumentDirectory() {
+        return FileSystem.getDocumentDirectory();
+    }
+    async resolveLocalFileSystemURL(url) {
+        return FileSystem.resolveLocalFileSystemURL(url);
+    }
+    async getFolderBasedOnUserId(userId) {
+        return FileSystem.getFolderBasedOnUserId(userId);
+    }
+    async deleteUserFolder(userId) {
+        return FileSystem.deleteUserFolder(userId);
+    }
+    getDatabaseAdapter() {
+        return DatabaseManager.getDatabaseAdapter();
+    }
+    getPushNotificationAdapter() {
+        try {
+            if (!this.pushNotification) {
+                this.pushNotification = new PushNotification();
+            }
+            return this.pushNotification;
+        }
+        catch (error) {
+            console.error('Error initializing push notification adapter:', error);
+            return null;
+        }
+    }
+    getLoggerAdapter() {
+        return {
+            logDebug: (sourceClass, method, message) => {
+                logger.logDebug(sourceClass, method, message);
+            },
+            logError: (sourceClass, method, message) => {
+                logger.logError(sourceClass, method, message);
+            },
+            logInfo: (sourceClass, method, message) => {
+                logger.logInfo(sourceClass, method, message);
+            },
+            setLogLevel: (logLevel) => {
+                logger.setLogLevel(logLevel);
+            },
+            getLogFileURL: async () => {
+                return logger.getLogFileURL();
+            },
+            getLogFileContent: async () => {
+                return logger.getLogFileContent() || '';
+            },
+            getBackupLogFileContent: async () => {
+                return logger.getBackupLogFileContent();
+            },
+            clearLogFile: async () => {
+                await logger.clearLogFile();
+            }
+        };
+    }
+    getStorageAdapter() {
+        return {
+            getItem: async (key) => {
+                return LocalStorage.getItem(key);
+            },
+            setItem: async (key, value) => {
+                return LocalStorage.setItem(key, value);
+            },
+            removeItem: async (key) => {
+                return LocalStorage.removeItem(key);
+            },
+            clear: async () => {
+                return LocalStorage.clear();
+            }
+        };
+    }
+}
+let platformInstance = null;
+export function getPlatformAdapter() {
+    if (!platformInstance) {
+        platformInstance = new ReactNativePlatformAdapter();
+    }
+    return platformInstance;
+}
+export function resetPlatformAdapter() {
+    platformInstance = null;
+}

package/dist/database/Database.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Database helper class with common database operations
+ */
+export declare class Database {
+    private dbName;
+    private location?;
+    constructor(dbName: string, location?: string);
+    /**
+     * Execute a raw SQL query
+     */
+    executeSql(query: string, params?: any[]): Promise<any[]>;
+    /**
+     * Create a table
+     */
+    createTable(tableName: string, columns: Record<string, string>): Promise<void>;
+    /**
+     * Drop a table
+     */
+    dropTable(tableName: string): Promise<void>;
+    /**
+     * Insert a record
+     */
+    insert(tableName: string, data: Record<string, any>): Promise<number>;
+    /**
+     * Insert multiple records in a transaction
+     */
+    insertBatch(tableName: string, records: Record<string, any>[]): Promise<void>;
+    /**
+     * Update records
+     */
+    update(tableName: string, data: Record<string, any>, where: string, whereParams?: any[]): Promise<number>;
+    /**
+     * Delete records
+     */
+    delete(tableName: string, where: string, whereParams?: any[]): Promise<number>;
+    /**
+     * Select records
+     */
+    select(tableName: string, columns?: string[], where?: string, whereParams?: any[], orderBy?: string, limit?: number): Promise<any[]>;
+    /**
+     * Select a single record
+     */
+    selectOne(tableName: string, columns?: string[], where?: string, whereParams?: any[]): Promise<any | null>;
+    /**
+     * Count records
+     */
+    count(tableName: string, where?: string, whereParams?: any[]): Promise<number>;
+    /**
+     * Check if a table exists
+     */
+    tableExists(tableName: string): Promise<boolean>;
+    /**
+     * Get all table names
+     */
+    getAllTables(): Promise<string[]>;
+    /**
+     * Clear all data from a table
+     */
+    truncate(tableName: string): Promise<void>;
+    /**
+     * Execute multiple SQL statements in a transaction
+     */
+    transaction(queries: Array<{
+        query: string;
+        params?: any[];
+    }>): Promise<void>;
+}
+/**
+ * Create a new database instance
+ */
+export declare function createDatabase(dbName: string, location?: string): Database;

package/dist/database/Database.js

@@ -0,0 +1,156 @@
+import { DatabaseManager } from './DatabaseManager';
+/**
+ * Database helper class with common database operations
+ */
+export class Database {
+    constructor(dbName, location) {
+        this.dbName = dbName;
+        this.location = location;
+    }
+    /**
+     * Execute a raw SQL query
+     */
+    async executeSql(query, params = []) {
+        return new Promise((resolve, reject) => {
+            const adapter = DatabaseManager.getDatabaseAdapter();
+            adapter.execute({ dbName: this.dbName, query, params }, (results) => resolve(results), (error) => reject(new Error(String(error))));
+        });
+    }
+    /**
+     * Create a table
+     */
+    async createTable(tableName, columns) {
+        const columnDefs = Object.entries(columns)
+            .map(([name, type]) => `${name} ${type}`)
+            .join(', ');
+        const query = `CREATE TABLE IF NOT EXISTS ${tableName} (${columnDefs})`;
+        await this.executeSql(query);
+    }
+    /**
+     * Drop a table
+     */
+    async dropTable(tableName) {
+        const query = `DROP TABLE IF EXISTS ${tableName}`;
+        await this.executeSql(query);
+    }
+    /**
+     * Insert a record
+     */
+    async insert(tableName, data) {
+        var _a;
+        const columns = Object.keys(data).join(', ');
+        const placeholders = Object.keys(data).map(() => '?').join(', ');
+        const values = Object.values(data);
+        const query = `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders})`;
+        const result = await this.executeSql(query, values);
+        // Return the insert ID if available
+        return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.insertId) || 0;
+    }
+    /**
+     * Insert multiple records in a transaction
+     */
+    async insertBatch(tableName, records) {
+        if (records.length === 0)
+            return;
+        const columns = Object.keys(records[0]).join(', ');
+        const placeholders = Object.keys(records[0]).map(() => '?').join(', ');
+        const query = `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders})`;
+        for (const record of records) {
+            const values = Object.values(record);
+            await this.executeSql(query, values);
+        }
+    }
+    /**
+     * Update records
+     */
+    async update(tableName, data, where, whereParams = []) {
+        var _a;
+        const setClause = Object.keys(data)
+            .map(key => `${key} = ?`)
+            .join(', ');
+        const values = [...Object.values(data), ...whereParams];
+        const query = `UPDATE ${tableName} SET ${setClause} WHERE ${where}`;
+        const result = await this.executeSql(query, values);
+        return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.rowsAffected) || 0;
+    }
+    /**
+     * Delete records
+     */
+    async delete(tableName, where, whereParams = []) {
+        var _a;
+        const query = `DELETE FROM ${tableName} WHERE ${where}`;
+        const result = await this.executeSql(query, whereParams);
+        return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.rowsAffected) || 0;
+    }
+    /**
+     * Select records
+     */
+    async select(tableName, columns = ['*'], where, whereParams = [], orderBy, limit) {
+        let query = `SELECT ${columns.join(', ')} FROM ${tableName}`;
+        if (where) {
+            query += ` WHERE ${where}`;
+        }
+        if (orderBy) {
+            query += ` ORDER BY ${orderBy}`;
+        }
+        if (limit) {
+            query += ` LIMIT ${limit}`;
+        }
+        return this.executeSql(query, whereParams);
+    }
+    /**
+     * Select a single record
+     */
+    async selectOne(tableName, columns = ['*'], where, whereParams = []) {
+        const results = await this.select(tableName, columns, where, whereParams, undefined, 1);
+        return results.length > 0 ? results[0] : null;
+    }
+    /**
+     * Count records
+     */
+    async count(tableName, where, whereParams = []) {
+        var _a;
+        let query = `SELECT COUNT(*) as count FROM ${tableName}`;
+        if (where) {
+            query += ` WHERE ${where}`;
+        }
+        const result = await this.executeSql(query, whereParams);
+        return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.count) || 0;
+    }
+    /**
+     * Check if a table exists
+     */
+    async tableExists(tableName) {
+        const query = `SELECT name FROM sqlite_master WHERE type='table' AND name=?`;
+        const result = await this.executeSql(query, [tableName]);
+        return result.length > 0;
+    }
+    /**
+     * Get all table names
+     */
+    async getAllTables() {
+        const query = `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;
+        const result = await this.executeSql(query);
+        return result.map(row => row.name);
+    }
+    /**
+     * Clear all data from a table
+     */
+    async truncate(tableName) {
+        await this.executeSql(`DELETE FROM ${tableName}`);
+    }
+    /**
+     * Execute multiple SQL statements in a transaction
+     */
+    async transaction(queries) {
+        for (const { query, params } of queries) {
+            await this.executeSql(query, params || []);
+        }
+    }
+}
+/**
+ * Create a new database instance
+ */
+export function createDatabase(dbName, location) {
+    return new Database(dbName, location);
+}

package/dist/database/DatabaseManager.d.ts

@@ -0,0 +1,32 @@
+import { IDatabaseAdapter } from './types';
+/**
+ * DatabaseManager - Manages SQLite database operations for React Native
+ */
+export declare class DatabaseManager {
+    private static databases;
+    private static defaultLocation;
+    /**
+     * Get or create a database connection
+     */
+    private static getDatabase;
+    /**
+     * Close a database connection
+     */
+    private static closeDatabase;
+    /**
+     * Convert SQLResultSet to array of objects
+     */
+    private static resultSetToArray;
+    /**
+     * Get the database adapter implementation
+     */
+    static getDatabaseAdapter(): IDatabaseAdapter;
+    /**
+     * Close all database connections
+     */
+    static closeAllDatabases(): Promise<void>;
+    /**
+     * Delete a database
+     */
+    static deleteDatabase(name: string, location?: string): Promise<void>;
+}