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

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0022
+R-0.000.0023

package/dist/database/Database.d.ts

@@ -10,60 +10,9 @@ export declare class Database {
      */
     executeSql(query: string, params?: any[]): Promise<any[]>;
     /**
-     * Create a table
+     * Delete a database
      */
-    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>;
+    deleteDB(): Promise<void>;
 }
 /**
  * Create a new database instance

package/dist/database/Database.js

@@ -17,135 +17,13 @@ export class Database {
         });
     }
     /**
-     * Create a table
+     * Delete a database
      */
-    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 || []);
-        }
+    async deleteDB() {
+        return new Promise((resolve, reject) => {
+            const adapter = DatabaseManager.getDatabaseAdapter();
+            adapter.deleteUserData({ dbName: this.dbName }, () => resolve(), (error) => reject(new Error(String(error))));
+        });
     }
 }
 /**

package/dist/database/services/DatabaseNative.js

@@ -9,10 +9,9 @@ export class DatabaseNative {
         if (this.databases.has(dbKey)) {
             return this.databases.get(dbKey);
         }
-        // @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.
+        if (!name) {
+            throw new Error("Database name is required");
+        }
         const db = open({ name });
         this.databases.set(dbKey, db);
         return db;
@@ -29,43 +28,105 @@ export class DatabaseNative {
                 }
             },
             execute: async (options, successCallback, errorCallback) => {
-                var _a;
                 try {
                     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);
+                    // FIX: Await the result properly
+                    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;
+                    if (rawRes) {
+                        if (rawRes.rows) {
+                            const rawRows = rawRes.rows;
+                            if (Array.isArray(rawRows)) {
+                                resultToReturn = rawRows;
+                            }
+                            else if (rawRows._array && Array.isArray(rawRows._array)) {
+                                resultToReturn = rawRows._array;
+                            }
+                            else if (typeof rawRows.length === 'number') {
+                                // JSI iterator
+                                for (let i = 0; i < rawRows.length; i++) {
+                                    // Use item() if available, otherwise index access
+                                    const r = rawRows.item ? rawRows.item(i) : rawRows[i];
+                                    resultToReturn.push(r);
+                                }
+                            }
+                        }
+                        else if (Array.isArray(rawRes)) {
+                            resultToReturn = rawRes;
+                        }
+                        // Attach insertId if present (though interface usually expects strict array, 
+                        // JS runtime allows attaching props to array)
+                        if (rawRes.insertId !== undefined) {
+                            resultToReturn.insertId = rawRes.insertId;
+                            resultToReturn.rowsAffected = rawRes.rowsAffected;
+                        }
+                    }
+                    successCallback(resultToReturn);
                 }
                 catch (error) {
                     errorCallback(error instanceof Error ? error.message : String(error));
                 }
             },
             executeStatementOnPath: async (dbPath, sqlQuery, callback) => {
-                var _a, _b;
+                var _a;
                 try {
                     const dbName = ((_a = dbPath.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(".db", "")) || "default";
                     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);
+                    const res = await db.execute(sqlQuery);
+                    let resultToReturn = [];
+                    const rawRes = res;
+                    if (rawRes && rawRes.rows) {
+                        const rawRows = rawRes.rows;
+                        if (typeof rawRows.length === 'number') {
+                            for (let i = 0; i < rawRows.length; i++) {
+                                const r = rawRows.item ? rawRows.item(i) : rawRows[i];
+                                resultToReturn.push(r);
+                            }
+                        }
+                        else if (Array.isArray(rawRows)) {
+                            resultToReturn = rawRows;
+                        }
+                        else if (rawRows._array) {
+                            resultToReturn = rawRows._array;
+                        }
+                    }
+                    // Attach insertId if present
+                    if (rawRes && rawRes.insertId !== undefined) {
+                        resultToReturn.insertId = rawRes.insertId;
+                        resultToReturn.rowsAffected = rawRes.rowsAffected;
+                    }
+                    callback(resultToReturn);
                 }
                 catch (error) {
                     callback([]);
                 }
             },
             selectFromPath: async (dbPath, sqlQuery, callback) => {
-                var _a, _b;
+                var _a;
                 try {
                     const dbName = ((_a = dbPath.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(".db", "")) || "default";
                     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);
+                    const res = await db.execute(sqlQuery);
+                    let resultToReturn = [];
+                    const rawRes = res;
+                    if (rawRes && rawRes.rows) {
+                        const rawRows = rawRes.rows;
+                        if (typeof rawRows.length === 'number') {
+                            for (let i = 0; i < rawRows.length; i++) {
+                                const r = rawRows.item ? rawRows.item(i) : rawRows[i];
+                                resultToReturn.push(r);
+                            }
+                        }
+                        else if (Array.isArray(rawRows)) {
+                            resultToReturn = rawRows;
+                        }
+                        else if (rawRows._array) {
+                            resultToReturn = rawRows._array;
+                        }
+                    }
+                    callback(resultToReturn);
                 }
                 catch (error) {
                     callback([]);
@@ -106,7 +167,7 @@ export class DatabaseNative {
                         ? "DELETE FROM user_data WHERE user_id = ?"
                         : "DELETE FROM user_data";
                     const params = options.userId ? [options.userId] : [];
-                    db.execute(query, params);
+                    await db.execute(query, params);
                     callback();
                 }
                 catch (error) {

package/package.json

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