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

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,12 @@
+import { IDatabaseAdapter } from './types';
+/**
+ * DatabaseManager - Manages database operations across platforms
+ * - iOS/Android/Windows: Uses react-native-sqlite-storage
+ * - Web: Uses WebSQL
+ */
+export declare class DatabaseManager {
+    /**
+     * Get the database adapter implementation
+     */
+    static getDatabaseAdapter(): IDatabaseAdapter;
+}

package/dist/database/DatabaseManager.js

@@ -0,0 +1,18 @@
+import { Platform } from 'react-native';
+import { DatabaseNative } from './services/DatabaseNative';
+import { DatabaseWeb } from './services/DatabaseWeb';
+// Select database implementation based on platform
+const dbImpl = Platform.OS === 'web' ? new DatabaseWeb() : new DatabaseNative();
+/**
+ * DatabaseManager - Manages database operations across platforms
+ * - iOS/Android/Windows: Uses react-native-sqlite-storage
+ * - Web: Uses WebSQL
+ */
+export class DatabaseManager {
+    /**
+     * Get the database adapter implementation
+     */
+    static getDatabaseAdapter() {
+        return dbImpl.getAdapter();
+    }
+}

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/services/DatabaseNative.d.ts

@@ -0,0 +1,8 @@
+import { IDatabaseAdapter } from "../types";
+export declare class DatabaseNative {
+    private databases;
+    private defaultLocation;
+    private getDatabase;
+    private resultSetToArray;
+    getAdapter(): IDatabaseAdapter;
+}

package/dist/database/services/DatabaseNative.js

@@ -0,0 +1,149 @@
+import SQLite from "react-native-sqlite-storage";
+SQLite.enablePromise(true);
+SQLite.DEBUG(false);
+export class DatabaseNative {
+    constructor() {
+        this.databases = new Map();
+        this.defaultLocation = "default";
+    }
+    async 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 });
+        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);
+                    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 = 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);
+                }
+                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 = await new Promise((resolve) => {
+                        db.transaction((tx) => {
+                            tx.executeSql(sqlQuery, [], (_, resultSet) => {
+                                resolve(this.resultSetToArray(resultSet));
+                            }, () => {
+                                resolve([]);
+                                return false;
+                            });
+                        });
+                    });
+                    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 = await new Promise((resolve) => {
+                        db.readTransaction((tx) => {
+                            tx.executeSql(sqlQuery, [], (_, resultSet) => {
+                                resolve(this.resultSetToArray(resultSet));
+                            }, () => {
+                                resolve([]);
+                                return false;
+                            });
+                        });
+                    });
+                    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(`${options.name}.db`);
+            },
+            saveWebDB: async (options, callback, errorCallback) => {
+                // Not needed for native - only for web
+                callback({
+                    success: true,
+                    message: "Not applicable for native",
+                });
+            },
+            exportWebDB: async (options, callback, errorCallback) => {
+                // Not needed for native - only for web
+                callback({
+                    success: true,
+                    message: "Not applicable for native",
+                });
+            },
+            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;
+                            });
+                        });
+                    });
+                    callback();
+                }
+                catch (error) {
+                    errorCallback(error instanceof Error ? error.message : String(error));
+                }
+            },
+        };
+    }
+}

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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,138 @@
+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));
+                }
+            }
+        };
+    }
+}

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 {};