@unvired/react-native-unvired-sdk 0.0.14 → 0.0.16

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0014
+R-0.000.0016

package/dist/database/DatabaseManager.d.ts

@@ -1,7 +1,7 @@
 import { IDatabaseAdapter } from './types';
 /**
  * DatabaseManager - Manages database operations across platforms
- * - iOS/Android/Windows: Uses react-native-sqlite-storage
+ * - iOS/Android/Windows: Uses @op-engineering/op-sqlite
  * - Web: Uses WebSQL
  */
 export declare class DatabaseManager {

package/dist/database/DatabaseManager.js

@@ -5,7 +5,7 @@ import { DatabaseWeb } from './services/DatabaseWeb';
 const dbImpl = Platform.OS === 'web' ? new DatabaseWeb() : new DatabaseNative();
 /**
  * DatabaseManager - Manages database operations across platforms
- * - iOS/Android/Windows: Uses react-native-sqlite-storage
+ * - iOS/Android/Windows: Uses @op-engineering/op-sqlite
  * - Web: Uses WebSQL
  */
 export class DatabaseManager {

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

@@ -3,6 +3,5 @@ export declare class DatabaseNative {
     private databases;
     private defaultLocation;
     private getDatabase;
-    private resultSetToArray;
     getAdapter(): IDatabaseAdapter;
 }

package/dist/database/services/DatabaseNative.js

@@ -1,33 +1,27 @@
-import SQLite from "react-native-sqlite-storage";
-SQLite.enablePromise(true);
-SQLite.DEBUG(false);
+import { open } from '@op-engineering/op-sqlite';
 export class DatabaseNative {
     constructor() {
         this.databases = new Map();
         this.defaultLocation = "default";
     }
-    async getDatabase(name, location) {
+    getDatabase(name, location) {
         const dbKey = `${name}_${location || this.defaultLocation}`;
         if (this.databases.has(dbKey)) {
             return this.databases.get(dbKey);
         }
-        const dbLocation = (location || this.defaultLocation);
-        const db = await SQLite.openDatabase({ name, location: dbLocation });
+        // @op-engineering/op-sqlite open function
+        // We treat location as mainly advisory since op-sqlite defaults to valid paths.
+        // If strict paths are needed, we would need to construct absolute path using FS.
+        // For now, we rely on the name.
+        const db = open({ name });
         this.databases.set(dbKey, db);
         return db;
     }
-    resultSetToArray(resultSet) {
-        const results = [];
-        for (let i = 0; i < resultSet.rows.length; i++) {
-            results.push(resultSet.rows.item(i));
-        }
-        return results;
-    }
     getAdapter() {
         return {
             create: async (options, successCallback, errorCallback) => {
                 try {
-                    await this.getDatabase(options.name, options.location);
+                    this.getDatabase(options.name, options.location);
                     successCallback({ success: true, database: options.name });
                 }
                 catch (error) {
@@ -35,61 +29,43 @@ export class DatabaseNative {
                 }
             },
             execute: async (options, successCallback, errorCallback) => {
+                var _a;
                 try {
-                    const db = await this.getDatabase(options.dbName);
-                    const results = await new Promise((resolve, reject) => {
-                        db.transaction((tx) => {
-                            tx.executeSql(options.query, options.params || [], (_, resultSet) => {
-                                resolve(this.resultSetToArray(resultSet));
-                            }, (_, error) => {
-                                reject(error);
-                                return false;
-                            });
-                        });
-                    });
-                    successCallback(results);
+                    const db = this.getDatabase(options.dbName);
+                    const res = db.execute(options.query, options.params);
+                    // op-sqlite v15+ returns rows as an array natively in most configurations
+                    // Check for _array for backward compatibility with some bridges or older habits
+                    // @ts-ignore
+                    const rows = ((_a = res.rows) === null || _a === void 0 ? void 0 : _a._array) || res.rows || [];
+                    successCallback(rows);
                 }
                 catch (error) {
                     errorCallback(error instanceof Error ? error.message : String(error));
                 }
             },
             executeStatementOnPath: async (dbPath, sqlQuery, callback) => {
-                var _a;
+                var _a, _b;
                 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 = await new Promise((resolve) => {
-                        db.transaction((tx) => {
-                            tx.executeSql(sqlQuery, [], (_, resultSet) => {
-                                resolve(this.resultSetToArray(resultSet));
-                            }, () => {
-                                resolve([]);
-                                return false;
-                            });
-                        });
-                    });
-                    callback(results);
+                    const db = this.getDatabase(dbName);
+                    const res = db.execute(sqlQuery);
+                    // @ts-ignore
+                    const rows = ((_b = res.rows) === null || _b === void 0 ? void 0 : _b._array) || res.rows || [];
+                    callback(rows);
                 }
                 catch (error) {
                     callback([]);
                 }
             },
             selectFromPath: async (dbPath, sqlQuery, callback) => {
-                var _a;
+                var _a, _b;
                 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 = await new Promise((resolve) => {
-                        db.readTransaction((tx) => {
-                            tx.executeSql(sqlQuery, [], (_, resultSet) => {
-                                resolve(this.resultSetToArray(resultSet));
-                            }, () => {
-                                resolve([]);
-                                return false;
-                            });
-                        });
-                    });
-                    callback(results);
+                    const db = this.getDatabase(dbName);
+                    const res = db.execute(sqlQuery);
+                    // @ts-ignore
+                    const rows = ((_b = res.rows) === null || _b === void 0 ? void 0 : _b._array) || res.rows || [];
+                    callback(rows);
                 }
                 catch (error) {
                     callback([]);
@@ -99,7 +75,7 @@ export class DatabaseNative {
                 var _a;
                 try {
                     const dbName = ((_a = dbPath.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(".db", "")) || "default";
-                    await this.getDatabase(dbName);
+                    this.getDatabase(dbName);
                     callback();
                 }
                 catch (error) {
@@ -125,19 +101,12 @@ export class DatabaseNative {
             },
             deleteUserData: async (options, callback, errorCallback) => {
                 try {
-                    const db = await this.getDatabase(options.dbName);
-                    await new Promise((resolve, reject) => {
-                        db.transaction((tx) => {
-                            const query = options.userId
-                                ? "DELETE FROM user_data WHERE user_id = ?"
-                                : "DELETE FROM user_data";
-                            const params = options.userId ? [options.userId] : [];
-                            tx.executeSql(query, params, () => resolve(), (_, error) => {
-                                reject(error);
-                                return false;
-                            });
-                        });
-                    });
+                    const db = 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.execute(query, params);
                     callback();
                 }
                 catch (error) {

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

@@ -1,9 +1,63 @@
-import { BaseFileSystem } from './BaseFileSystem';
+import { IFileEntry, FileSystemEncoding } from './FileSystem.types';
 /**
  * FileSystem class
- * Extends BaseFileSystem
+ * Handles file system operations for React Native
+ * - iOS/Android/Windows: Uses react-native-fs
+ * - Web: Limited functionality (not supported)
  */
-export declare class FileSystem extends BaseFileSystem {
+export declare class FileSystem {
+    /**
+     * Get document directory path
+     */
+    static getDocumentDirectory(): string;
+    /**
+     * Resolve local file system URL
+     */
+    static resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;
+    /**
+     * Get folder based on user ID
+     */
+    static getFolderBasedOnUserId(userId: string): Promise<string>;
+    /**
+     * Delete user folder
+     */
+    static deleteUserFolder(userId: string): Promise<void>;
+    /**
+     * Create directory
+     */
+    static createDirectory(path: string): Promise<void>;
+    /**
+     * Read file content
+     */
+    static readFile(path: string, encoding?: FileSystemEncoding): Promise<string>;
+    /**
+     * Write file content
+     */
+    static writeFile(path: string, content: string, encoding?: FileSystemEncoding): Promise<void>;
+    /**
+     * Delete file
+     */
+    static deleteFile(path: string): Promise<void>;
+    /**
+     * Check if file exists
+     */
+    static exists(path: string): Promise<boolean>;
+    /**
+     * Get file info
+     */
+    static stat(path: string): Promise<any>;
+    /**
+     * List directory contents
+     */
+    static readDir(path: string): Promise<any[]>;
+    /**
+     * Copy file
+     */
+    static copyFile(source: string, destination: string): Promise<void>;
+    /**
+     * Move file
+     */
+    static moveFile(source: string, destination: string): Promise<void>;
 }
 export type { IFileEntry } from './FileSystem.types';
 export default FileSystem;

package/dist/file-system/FileSystem.js

@@ -1,11 +1,164 @@
-// FileSystem.ts
-// Main file system export
-import { BaseFileSystem } from './BaseFileSystem';
+import { Platform } from 'react-native';
+import { FileSystemNative } from './services/FileSystemNative';
+import { FileSystemWeb } from './services/FileSystemWeb';
+// Select file system implementation based on platform
+const fsImpl = Platform.OS === 'web' ? new FileSystemWeb() : new FileSystemNative();
 /**
  * FileSystem class
- * Extends BaseFileSystem
+ * Handles file system operations for React Native
+ * - iOS/Android/Windows: Uses react-native-fs
+ * - Web: Limited functionality (not supported)
  */
-export class FileSystem extends BaseFileSystem {
+export class FileSystem {
+    /**
+     * Get document directory path
+     */
+    static getDocumentDirectory() {
+        return fsImpl.getDocumentDirectory();
+    }
+    /**
+     * Resolve local file system URL
+     */
+    static async resolveLocalFileSystemURL(url) {
+        try {
+            return await fsImpl.resolveLocalFileSystemURL(url);
+        }
+        catch (error) {
+            console.error('Error resolving file system URL:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get folder based on user ID
+     */
+    static async getFolderBasedOnUserId(userId) {
+        try {
+            return await fsImpl.getFolderBasedOnUserId(userId);
+        }
+        catch (error) {
+            console.error('Error getting user folder:', error);
+            throw error;
+        }
+    }
+    /**
+     * Delete user folder
+     */
+    static async deleteUserFolder(userId) {
+        try {
+            await fsImpl.deleteUserFolder(userId);
+        }
+        catch (error) {
+            console.error('Error deleting user folder:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create directory
+     */
+    static async createDirectory(path) {
+        try {
+            await fsImpl.createDirectory(path);
+        }
+        catch (error) {
+            console.error('Error creating directory:', error);
+            throw error;
+        }
+    }
+    /**
+     * Read file content
+     */
+    static async readFile(path, encoding = 'utf8') {
+        try {
+            return await fsImpl.readFile(path, encoding);
+        }
+        catch (error) {
+            console.error('Error reading file:', error);
+            throw error;
+        }
+    }
+    /**
+     * Write file content
+     */
+    static async writeFile(path, content, encoding = 'utf8') {
+        try {
+            await fsImpl.writeFile(path, content, encoding);
+        }
+        catch (error) {
+            console.error('Error writing file:', error);
+            throw error;
+        }
+    }
+    /**
+     * Delete file
+     */
+    static async deleteFile(path) {
+        try {
+            await fsImpl.deleteFile(path);
+        }
+        catch (error) {
+            console.error('Error deleting file:', error);
+            throw error;
+        }
+    }
+    /**
+     * Check if file exists
+     */
+    static async exists(path) {
+        try {
+            return await fsImpl.exists(path);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Get file info
+     */
+    static async stat(path) {
+        try {
+            return await fsImpl.stat(path);
+        }
+        catch (error) {
+            console.error('Error getting file stats:', error);
+            throw error;
+        }
+    }
+    /**
+     * List directory contents
+     */
+    static async readDir(path) {
+        try {
+            return await fsImpl.readDir(path);
+        }
+        catch (error) {
+            console.error('Error reading directory:', error);
+            throw error;
+        }
+    }
+    /**
+     * Copy file
+     */
+    static async copyFile(source, destination) {
+        try {
+            await fsImpl.copyFile(source, destination);
+        }
+        catch (error) {
+            console.error('Error copying file:', error);
+            throw error;
+        }
+    }
+    /**
+     * Move file
+     */
+    static async moveFile(source, destination) {
+        try {
+            await fsImpl.moveFile(source, destination);
+        }
+        catch (error) {
+            console.error('Error moving file:', error);
+            throw error;
+        }
+    }
 }
 // Default export
 export default FileSystem;

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

@@ -1,11 +1,41 @@
 /**
  * File entry interface
  */
+export interface IDirectoryReader {
+    readEntries(successCallback: (entries: IFileEntry[]) => void, errorCallback: (error: any) => void): void;
+}
 export interface IFileEntry {
     isFile: boolean;
     isDirectory: boolean;
     name: string;
     fullPath: string;
     filesystem?: any;
-    nativeURL?: string;
+    nativeURL: string;
+    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: any) => void, errorCallback: (error: any) => void): void;
+    createWriter?(callback: (writer: any) => void, errorCallback: (error: any) => void): void;
+}
+export type FileSystemEncoding = 'utf8' | 'ascii' | 'base64';
+export interface IFileSystem {
+    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>;
 }

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

@@ -0,0 +1,55 @@
+import { IFileEntry, IDirectoryReader } from './FileSystem.types';
+/**
+ * DirectoryReader implementation for React Native
+ * Wraps RNFS.readDir to match the Cordova DirectoryReader interface
+ */
+export declare class RNDirectoryReader implements IDirectoryReader {
+    private dirPath;
+    constructor(dirPath: string);
+    readEntries(callback: (entries: IFileEntry[]) => void, errorCallback: (error: any) => void): void;
+}
+/**
+ * FileEntry implementation for React Native
+ * Wraps react-native-fs to match the Cordova FileEntry interface
+ */
+export declare class RNFileEntry implements IFileEntry {
+    isFile: boolean;
+    isDirectory: boolean;
+    name: string;
+    fullPath: string;
+    nativeURL: string;
+    filesystem: any;
+    constructor(path: string, isDirectory?: boolean);
+    /**
+     * Remove a file or empty directory
+     */
+    remove(callback: () => void, errorCallback: (error: any) => void): void;
+    /**
+     * Remove a directory and all its contents recursively
+     */
+    removeRecursively(callback: () => void, errorCallback: (error: any) => void): void;
+    /**
+     * Create a directory reader for reading directory contents
+     */
+    createReader(): IDirectoryReader;
+    /**
+     * Get or create a subdirectory
+     */
+    getDirectory(path: string, options: {
+        create: boolean;
+    }, callback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    /**
+     * Get or create a file
+     */
+    getFile(path: string, options: {
+        create: boolean;
+    }, callback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    /**
+     * Get file metadata
+     */
+    file(callback: (file: any) => void, errorCallback: (error: any) => void): void;
+    /**
+     * Create a file writer for writing to the file
+     */
+    createWriter(callback: (writer: any) => void, errorCallback: (error: any) => void): void;
+}