@capacitor-community/sqlite 5.0.5 → 5.0.7-1

package/electron/dist/plugin.js

@@ -11,6 +11,8 @@ var require$$5 = require('jszip');
 var require$$6 = require('electron');
 var require$$1$1 = require('better-sqlite3-multiple-ciphers');
 var require$$3$1 = require('electron-json-storage');
+var require$$1$2 = require('crypto');
+var require$$2$1 = require('crypto-js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -23,6 +25,8 @@ var require$$5__default = /*#__PURE__*/_interopDefaultLegacy(require$$5);
 var require$$6__default = /*#__PURE__*/_interopDefaultLegacy(require$$6);
 var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
 var require$$3__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$3$1);
+var require$$1__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$1$2);
+var require$$2__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$2$1);
 
 var src = {};
 
@@ -110,7 +114,6 @@ class UtilsFile {
             default:
                 console.log('other operating system');
         }
-        console.log(`&&& Databases path: ${this.pathDB}`);
     }
     /**
      * Get isEncryption from config
@@ -670,13 +673,13 @@ class UtilsSQLite {
         let mDB;
         if (!readonly) {
             mDB = new this.BCSQLite3(pathDB, {
-                verbose: console.log,
+                //        verbose: console.log,
                 fileMustExist: false,
             });
         }
         else {
             mDB = new this.BCSQLite3(pathDB, {
-                verbose: console.log,
+                //        verbose: console.log,
                 readonly: true,
                 fileMustExist: true,
             });
@@ -3545,55 +3548,20 @@ class ImportFromJson {
 }
 importFromJson.ImportFromJson = ImportFromJson;
 
-var utilsEncryption = {};
-
-Object.defineProperty(utilsEncryption, "__esModule", { value: true });
-utilsEncryption.UtilsEncryption = void 0;
-const utilsFile_1$3 = utilsFile;
-const utilsSQLite_1$4 = utilsSQLite;
-class UtilsEncryption {
-    constructor() {
-        this.fileUtil = new utilsFile_1$3.UtilsFile();
-        this.sqliteUtil = new utilsSQLite_1$4.UtilsSQLite();
-    }
-    /**
-     * EncryptDatabase
-     * @param pathDB
-     * @param password
-     */
-    async encryptDatabase(pathDB, password) {
-        const msg = 'EncryptDatabase: ';
-        const retB = this.fileUtil.isPathExists(pathDB);
-        if (retB) {
-            try {
-                const mDB = await this.sqliteUtil.openOrCreateDatabase(pathDB, '', false);
-                this.sqliteUtil.pragmaReKey(mDB, '', password);
-                this.sqliteUtil.closeDB(mDB);
-                return Promise.resolve();
-            }
-            catch (err) {
-                return Promise.reject(new Error(`${msg} ${err.message} `));
-            }
-        }
-        else {
-            return Promise.reject(new Error(`${msg}file path ${pathDB} ` + 'does not exist'));
-        }
-    }
-}
-utilsEncryption.UtilsEncryption = UtilsEncryption;
+var utilsJsonEncryption = {};
 
 var utilsSecret = {};
 
 Object.defineProperty(utilsSecret, "__esModule", { value: true });
 utilsSecret.UtilsSecret = void 0;
 const GlobalSQLite_1$2 = GlobalSQLite$1;
-const utilsFile_1$2 = utilsFile;
-const utilsSQLite_1$3 = utilsSQLite;
+const utilsFile_1$3 = utilsFile;
+const utilsSQLite_1$4 = utilsSQLite;
 class UtilsSecret {
     constructor() {
         this.globalUtil = new GlobalSQLite_1$2.GlobalSQLite();
-        this.sqliteUtil = new utilsSQLite_1$3.UtilsSQLite();
-        this.fileUtil = new utilsFile_1$2.UtilsFile();
+        this.sqliteUtil = new utilsSQLite_1$4.UtilsSQLite();
+        this.fileUtil = new utilsFile_1$3.UtilsFile();
         this.storage = require$$3__default$1["default"];
     }
     isSecretStored() {
@@ -3714,6 +3682,103 @@ class UtilsSecret {
 }
 utilsSecret.UtilsSecret = UtilsSecret;
 
+Object.defineProperty(utilsJsonEncryption, "__esModule", { value: true });
+utilsJsonEncryption.UtilsJsonEncryption = void 0;
+const utilsSecret_1$2 = utilsSecret;
+class UtilsJsonEncryption {
+    constructor() {
+        this.fileSecret = new utilsSecret_1$2.UtilsSecret();
+        this.SALT = 'jeep_capacitor_sqlite';
+        this.Crypto = require$$1__default$2["default"];
+        this.CryptoJS = require$$2__default$1["default"];
+    }
+    /**
+     * deriveKeyFromPassphrase
+     * Function to derive a symmetric key from passphrase and salt using PBKDF2
+     * @param passphrase
+     * @param salt
+     * @returns
+     */
+    deriveKeyFromPassphrase(passphrase, salt) {
+        const iterations = 10000; // Recommended number of iterations for PBKDF2
+        const keyLength = 32;
+        const key = this.Crypto.pbkdf2Sync(passphrase, salt, iterations, keyLength, 'sha256');
+        const keyHex = Buffer.from(key).toString('hex');
+        return keyHex;
+    }
+    /**
+     * encryptJSONObject
+     * Function to encrypt JSON object with AES and return as Base64
+     * @param jsonObj
+     * @returns
+     */
+    encryptJSONObject(jsonObj) {
+        const jsonString = JSON.stringify(jsonObj);
+        // get the passphrase
+        const passphrase = this.fileSecret.getPassphrase();
+        // derived a combined key from passphrase and salt
+        const key = this.deriveKeyFromPassphrase(passphrase, this.SALT);
+        const encrypted = this.CryptoJS.AES.encrypt(jsonString, key).toString();
+        const encryptedBase64 = Buffer.from(encrypted).toString('base64');
+        return encryptedBase64;
+    }
+    /**
+     * decryptJSONObject
+     * Function to decrypt AES encrypted JSON object from Base64
+     * @param encryptedBase64
+     * @returns
+     */
+    decryptJSONObject(encryptedBase64) {
+        const encryptedData = Buffer.from(encryptedBase64, 'base64').toString();
+        // get the passphrase
+        const passphrase = this.fileSecret.getPassphrase();
+        // derived a combined key from passphrase and salt
+        const key = this.deriveKeyFromPassphrase(passphrase, this.SALT);
+        const bytes = this.CryptoJS.AES.decrypt(encryptedData, key);
+        const decryptedString = bytes.toString(this.CryptoJS.enc.Utf8);
+        const decryptedObj = JSON.parse(decryptedString);
+        return decryptedObj;
+    }
+}
+utilsJsonEncryption.UtilsJsonEncryption = UtilsJsonEncryption;
+
+var utilsEncryption = {};
+
+Object.defineProperty(utilsEncryption, "__esModule", { value: true });
+utilsEncryption.UtilsEncryption = void 0;
+const utilsFile_1$2 = utilsFile;
+const utilsSQLite_1$3 = utilsSQLite;
+class UtilsEncryption {
+    constructor() {
+        this.fileUtil = new utilsFile_1$2.UtilsFile();
+        this.sqliteUtil = new utilsSQLite_1$3.UtilsSQLite();
+    }
+    /**
+     * EncryptDatabase
+     * @param pathDB
+     * @param password
+     */
+    async encryptDatabase(pathDB, password) {
+        const msg = 'EncryptDatabase: ';
+        const retB = this.fileUtil.isPathExists(pathDB);
+        if (retB) {
+            try {
+                const mDB = await this.sqliteUtil.openOrCreateDatabase(pathDB, '', false);
+                this.sqliteUtil.pragmaReKey(mDB, '', password);
+                this.sqliteUtil.closeDB(mDB);
+                return Promise.resolve();
+            }
+            catch (err) {
+                return Promise.reject(new Error(`${msg} ${err.message} `));
+            }
+        }
+        else {
+            return Promise.reject(new Error(`${msg}file path ${pathDB} ` + 'does not exist'));
+        }
+    }
+}
+utilsEncryption.UtilsEncryption = UtilsEncryption;
+
 var utilsUpgrade = {};
 
 Object.defineProperty(utilsUpgrade, "__esModule", { value: true });
@@ -3785,13 +3850,15 @@ const GlobalSQLite_1$1 = GlobalSQLite$1;
 const exportToJson_1 = exportToJson;
 const importFromJson_1 = importFromJson;
 const utilsJson_1$1 = utilsJson;
+const utilsJsonEncryption_1$1 = utilsJsonEncryption;
 const utilsEncryption_1 = utilsEncryption;
 const utilsFile_1$1 = utilsFile;
 const utilsSQLite_1$1 = utilsSQLite;
 const utilsSecret_1$1 = utilsSecret;
 const utilsUpgrade_1 = utilsUpgrade;
 class Database {
-    constructor(dbName, encrypted, mode, version, readonly, upgDict, globalUtil) {
+    constructor(dbName, encrypted, mode, version, isEncryption, readonly, upgDict, globalUtil) {
+        this.jsonEncryptUtil = new utilsJsonEncryption_1$1.UtilsJsonEncryption();
         this.fileUtil = new utilsFile_1$1.UtilsFile();
         this.sqliteUtil = new utilsSQLite_1$1.UtilsSQLite();
         this.jsonUtil = new utilsJson_1$1.UtilsJson();
@@ -3805,6 +3872,7 @@ class Database {
         this.dbName = dbName;
         this._encrypted = encrypted;
         this._mode = mode;
+        this._isEncryption = isEncryption;
         this.version = version;
         this.readonly = readonly;
         this.upgradeVersionDict = upgDict;
@@ -3813,6 +3881,7 @@ class Database {
         this.globalUtil = globalUtil ? globalUtil : new GlobalSQLite_1$1.GlobalSQLite();
         if (this.pathDB.length === 0)
             throw new Error('Could not generate a path to ' + dbName);
+        console.log(`&&& Databases path: ${this.pathDB}`);
     }
     /**
      * IsDBOpen
@@ -4271,13 +4340,21 @@ class Database {
             if (isTable) {
                 this.exportToJsonUtil.setLastExportDate(this.database, new Date().toISOString());
             }
-            const jsonResult = this.exportToJsonUtil.createExportObject(this.database, inJson);
+            let jsonResult = this.exportToJsonUtil.createExportObject(this.database, inJson);
             const keys = Object.keys(jsonResult);
             if (keys.length === 0) {
                 const msg = `ExportJson: return Object is empty ` + `No data to synchronize`;
                 throw new Error(msg);
             }
-            const isValid = this.jsonUtil.isJsonSQLite(jsonResult);
+            let isValid = this.jsonUtil.isJsonSQLite(jsonResult);
+            if (this._encrypted && this._isEncryption) {
+                jsonResult.overwrite = true;
+                jsonResult.encrypted = true;
+                const base64Str = this.jsonEncryptUtil.encryptJSONObject(jsonResult);
+                jsonResult = {};
+                jsonResult.expData = base64Str;
+                isValid = true;
+            }
             if (isValid) {
                 return jsonResult;
             }
@@ -4305,6 +4382,7 @@ exports.CapacitorSQLite = src.CapacitorSQLite = void 0;
 const GlobalSQLite_1 = GlobalSQLite$1;
 const Database_1 = Database$1;
 const utilsJson_1 = utilsJson;
+const utilsJsonEncryption_1 = utilsJsonEncryption;
 const utilsFile_1 = utilsFile;
 const utilsSQLite_1 = utilsSQLite;
 const utilsSecret_1 = utilsSecret;
@@ -4314,6 +4392,7 @@ class CapacitorSQLite {
         this.databases = {};
         this.fileUtil = new utilsFile_1.UtilsFile();
         this.jsonUtil = new utilsJson_1.UtilsJson();
+        this.jsonEncryptUtil = new utilsJsonEncryption_1.UtilsJsonEncryption();
         this.sqliteUtil = new utilsSQLite_1.UtilsSQLite();
         this.secretUtil = new utilsSecret_1.UtilsSecret();
         this.globalUtil = new GlobalSQLite_1.GlobalSQLite();
@@ -4347,7 +4426,7 @@ class CapacitorSQLite {
             upgrades = this.versionUpgrades[dbName];
         }
         const connName = readonly ? 'RO_' + dbName : 'RW_' + dbName;
-        const databaseConnection = new Database_1.Database(dbName + 'SQLite.db', encrypted, inMode, version, readonly, upgrades, this.globalUtil);
+        const databaseConnection = new Database_1.Database(dbName + 'SQLite.db', encrypted, inMode, version, this.isEncryption, readonly, upgrades, this.globalUtil);
         this.databases[connName] = databaseConnection;
         return;
     }
@@ -4644,7 +4723,14 @@ class CapacitorSQLite {
     }
     async importFromJson(options) {
         const jsonString = this.getOptionValue(options, 'jsonstring');
-        const jsonObj = JSON.parse(jsonString);
+        let jsonObj = JSON.parse(jsonString);
+        let inMode = 'no-encryption';
+        const key = 'expData';
+        if (key in jsonObj) {
+            // Decrypt the data
+            inMode = 'secret';
+            jsonObj = this.jsonEncryptUtil.decryptJSONObject(jsonObj.expData);
+        }
         const isValid = this.jsonUtil.isJsonSQLite(jsonObj);
         if (!isValid) {
             throw new Error('Must provide a valid JsonSQLite Object');
@@ -4654,12 +4740,12 @@ class CapacitorSQLite {
         const targetDbVersion = vJsonObj.version ?? 1;
         const overwrite = vJsonObj.overwrite ?? false;
         const encrypted = vJsonObj.encrypted ?? false;
-        const mode = vJsonObj.mode ?? 'no-encryption';
+        const mode = vJsonObj.mode ?? 'full';
         if (!this.isEncryption && encrypted) {
             throw new Error('Must set electronIsEncryption = true in capacitor.config.ts');
         }
         // Create the database
-        const database = new Database_1.Database(dbName, encrypted, mode, targetDbVersion, false, {}, this.globalUtil);
+        const database = new Database_1.Database(dbName, encrypted, inMode, targetDbVersion, this.isEncryption, false, {}, this.globalUtil);
         try {
             if (overwrite && mode === 'full') {
                 const isExists = this.fileUtil.isFileExists(dbName);
@@ -4682,7 +4768,7 @@ class CapacitorSQLite {
             // Import the JsonSQLite Object
             const changes = await database.importJson(vJsonObj);
             // Close the database
-            await database.dbClose();
+            database.dbClose();
             return { changes: { changes: changes } };
         }
         catch (err) {
@@ -4697,7 +4783,7 @@ class CapacitorSQLite {
         const database = this.getDatabaseConnectionOrThrowError(connName);
         if (database.isDBOpen()) {
             try {
-                const exportJsonResult = await database.exportJson(exportMode);
+                const exportJsonResult = database.exportJson(exportMode);
                 const resultKeys = Object.keys(exportJsonResult);
                 if (resultKeys.includes('message')) {
                     throw new Error(`exportToJson: ${exportJsonResult.message}`);