@capacitor-community/sqlite 5.2.3 → 5.2.4

package/ios/Plugin/CapacitorSQLitePlugin.swift

@@ -6,7 +6,8 @@ import Capacitor
 // swiftlint:disable type_body_length
 public class CapacitorSQLitePlugin: CAPPlugin {
     private var implementation: CapacitorSQLite?
-    private let modeList: [String] = ["no-encryption", "encryption", "secret", "newsecret", "wrongsecret"]
+    private let modeList: [String] = ["no-encryption", "encryption", "secret",
+                                      "decryption", "newsecret", "wrongsecret"]
     private let retHandler: ReturnHandler = ReturnHandler()
     private var versionUpgrades: [String: [Int: [String: Any]]] = [:]
     var importObserver: Any?
@@ -239,7 +240,7 @@ public class CapacitorSQLitePlugin: CAPPlugin {
         if encrypted && !modeList.contains(inMode) {
             var msg: String = "CreateConnection: inMode "
             msg.append("must be in['encryption',")
-            msg.append("'secret','newsecret']")
+            msg.append("'secret','decryption']")
             retHandler.rResult(call: call, message: msg)
             return
         }

package/ios/Plugin/Database.swift

@@ -107,7 +107,9 @@ class Database {
     // swiftlint:disable function_body_length
     func open () throws {
         var password: String = ""
-        if isEncryption && encrypted && (mode == "secret" || mode == "encryption") {
+        if isEncryption && encrypted && (mode == "secret"
+                                            || mode == "encryption"
+                                            || mode == "decryption") {
             let isPassphrase = try UtilsSecret.isPassphrase(account: account)
             if !isPassphrase {
                 let msg: String = "No Passphrase stored"
@@ -135,6 +137,28 @@ class Database {
                 throw DatabaseError.open(message: msg)
             }
 
+        }
+        if mode == "decryption" {
+            if isEncryption {
+                do {
+                    let ret: Bool = try UtilsEncryption
+                        .decryptDatabase(databaseLocation: databaseLocation,
+                                         filePath: path, password: password,
+                                         version: dbVersion)
+                    if !ret {
+                        let msg: String = "Failed in decryption"
+                        throw DatabaseError.open(message: msg)
+                    }
+                    password = ""
+                } catch UtilsEncryptionError.decryptionFailed(let message) {
+                    let msg: String = "Failed in decryption \(message)"
+                    throw DatabaseError.open(message: msg)
+                }
+            } else {
+                let msg: String = "No Encryption set in capacitor.config"
+                throw DatabaseError.open(message: msg)
+            }
+
         }
 
         do {
@@ -236,7 +260,7 @@ class Database {
             throw DatabaseError.isAvailTrans(message: msg)
         }
     }
-    
+
     // MARK: - SetIsTransActive
 
     func setIsTransActive(newValue: Bool ) {
@@ -653,7 +677,7 @@ class Database {
     // MARK: - ExportToJson
 
     func exportToJson(expMode: String, isEncrypted: Bool)
-                                throws -> [String: Any] {
+    throws -> [String: Any] {
         var retObj: [String: Any] = [:]
 
         do {

package/ios/Plugin/ImportExportJson/ImportFromJson.swift

@@ -105,7 +105,7 @@ class ImportFromJson {
                         try UtilsSQLCipher
                             .rollbackTransaction(mDB: mDB)
                         mDB.setIsTransActive(newValue: false)
-                   } catch UtilsSQLCipherError
+                    } catch UtilsSQLCipherError
                                 .rollbackTransaction(let message) {
                         throw ImportFromJsonError
                         .createSchema(message: message)
@@ -615,7 +615,7 @@ class ImportFromJson {
                     try UtilsSQLCipher
                         .rollbackTransaction(mDB: mDB)
                     mDB.setIsTransActive(newValue: false)
-                   throw ImportFromJsonError
+                    throw ImportFromJsonError
                     .createViews(message: msg)
                 } catch UtilsSQLCipherError
                             .rollbackTransaction(let message) {

package/ios/Plugin/Utils/UtilsDelete.swift

@@ -290,7 +290,7 @@ class UtilsDelete {
         var relatedItems: [[String: Any]] = []
         var key: String = ""
         let t1Names = withRefsNames.map { "t1.\($0)" }
-        let t2Names = colNames.map { "t2.\($0)" }
+        let t2Names = colNames.map{ "t2.\($0)" }
 
         do {
             var whereClause = try UtilsSQLStatement
@@ -301,9 +301,8 @@ class UtilsDelete {
                 whereClause = String(whereClause.dropLast())
             }
             let resultString = zip(t1Names, t2Names)
-                .map {"\($0) = \($1)" }
+                .map { "\($0) = \($1)" }
                 .joined(separator: " AND ")
-
             let sql = "SELECT t1.rowid FROM \(updTableName) t1 " +
                 "JOIN \(tableName) t2 ON \(resultString) " +
                 "WHERE \(whereClause) AND t1.sql_deleted = 0;"

package/ios/Plugin/Utils/UtilsEncryption.swift

@@ -11,6 +11,7 @@ import SQLCipher
 
 enum UtilsEncryptionError: Error {
     case encryptionFailed(message: String)
+    case decryptionFailed(message: String)
 }
 class UtilsEncryption {
 
@@ -87,5 +88,79 @@ class UtilsEncryption {
         return ret
     }
 
+    // MARK: - DecryptDatabase
+
+    // swiftlint:disable function_body_length
+    class func decryptDatabase(databaseLocation: String, filePath: String,
+                               password: String, version: Int) throws -> Bool {
+        var ret: Bool = false
+        var oDB: OpaquePointer?
+        var eDB: OpaquePointer?
+        do {
+            if UtilsFile.isFileExist(filePath: filePath) {
+                do {
+                    let tempPath: String = try UtilsFile
+                        .getFilePath(databaseLocation: databaseLocation,
+                                     fileName: "temp.db")
+                    try UtilsFile.renameFile(filePath: filePath,
+                                             toFilePath: tempPath,
+                                             databaseLocation: databaseLocation)
+                    oDB = try UtilsSQLCipher
+                        .openOrCreateDatabase(filename: tempPath,
+                                              password: password,
+                                              readonly: false)
+                    eDB = try UtilsSQLCipher
+                        .openOrCreateDatabase(filename: filePath,
+                                              password: "",
+                                              readonly: false)
+
+                    var stmt: String = "PRAGMA key = '\(password)';"
+                    stmt.append("ATTACH DATABASE '\(filePath)' ")
+                    stmt.append("AS plaintext KEY '';")
+                    stmt.append("SELECT sqlcipher_export('plaintext');")
+                    stmt.append("DETACH DATABASE plaintext;")
+                    if sqlite3_exec(oDB, stmt, nil, nil, nil) ==
+                        SQLITE_OK {
+                        try _ = UtilsFile
+                            .deleteFile(fileName: "temp.db",
+                                        databaseLocation: databaseLocation)
+                        // set the version
+                        let sqltr: String = "PRAGMA user_version = \(version);"
+                        if sqlite3_exec(eDB, sqltr, nil, nil, nil) != SQLITE_OK {
+                            throw UtilsEncryptionError
+                            .decryptionFailed(message: "set version to \(version) failed")
+                        }
+
+                        ret = true
+                    }
+                    // close the db
+                    try UtilsSQLCipher.close(oDB: oDB)
+
+                } catch UtilsFileError.getFilePathFailed {
+                    throw UtilsEncryptionError
+                    .decryptionFailed(message: "file path failed")
+                } catch UtilsFileError.renameFileFailed {
+                    throw UtilsEncryptionError
+                    .decryptionFailed(message: "file rename failed")
+                } catch UtilsSQLCipherError.openOrCreateDatabase(_) {
+                    throw UtilsEncryptionError
+                    .decryptionFailed(message: "open failed")
+                } catch UtilsSQLCipherError.close(_) {
+                    throw UtilsEncryptionError
+                    .decryptionFailed(message: "close failed")
+                } catch let error {
+                    print("Error: \(error)")
+                    throw UtilsEncryptionError
+                    .decryptionFailed(message: "Error: \(error)")
+                }
+            }
+        } catch let error {
+            print("Error: \(error)")
+            throw UtilsEncryptionError
+            .decryptionFailed(message: "Error: \(error)")
+        }
+        return ret
+    }
+
 }
 // swiftlint:enable function_body_length

package/ios/Plugin/Utils/UtilsSQLCipher.swift

@@ -665,9 +665,9 @@ class UtilsSQLCipher {
                         "WHERE Statement"
                     throw UtilsSQLCipherError.deleteSQL(message: msg)
                 }
-/*
-                let curTime =         UtilsDelete.getCurrentTimeAsInteger()
-*/
+                /*
+                 let curTime =         UtilsDelete.getCurrentTimeAsInteger()
+                 */
                 let setStmt = "sql_deleted = 1"
                 // Find REFERENCIES if any and update the sql_deleted
                 // column

package/ios/Plugin/Utils/UtilsSQLStatement.swift

@@ -7,7 +7,6 @@
 
 import Foundation
 enum UtilsSQLStatementError: Error {
-    case extractColumnNames(message: String)
     case extractForeignKeyInfo(message: String)
     case addPrefixToWhereClause(message: String)
 }
@@ -69,8 +68,8 @@ class UtilsSQLStatement {
     // MARK: - addPrefixToWhereClause
 
     class func addPrefixToWhereClause(_ whereClause: String,
-                                        from: [String],
-                                        to: [String], prefix: String)
+                                      from: [String],
+                                      to: [String], prefix: String)
     throws -> String {
         var columnValuePairs: [String]
         if whereClause.contains("AND") {
@@ -141,6 +140,7 @@ class UtilsSQLStatement {
     }
     // MARK: - extractForeignKeyInfo
 
+    // swiftlint:enable function_body_length
     // swiftlint:enable type_body_length
     class func extractForeignKeyInfo(from sqlStatement: String)
     throws ->
@@ -225,32 +225,95 @@ class UtilsSQLStatement {
         return foreignKeyInfo
     }
     // swiftlint:enable type_body_length
+    // swiftlint:disable function_body_length
 
     // MARK: - extractColumnNames
 
+    // swiftlint:disable function_body_length
     class func extractColumnNames(from whereClause: String) -> [String] {
         let keywords: Set<String> = ["AND", "OR", "IN", "VALUES", "LIKE", "BETWEEN", "NOT"]
-        let tokens = whereClause.components(separatedBy: CharacterSet(charactersIn: " ,()"))
+        let operators: Set<String> = ["=", "<", "<=", ">=", ">", "<>"]
 
         var columns = [String]()
         var inClause = false
         var inValues = false
+        var betweenClause = false
+        var andClause = false
+        var inPar = false
+        var inOper = false
+        var inLike = false
+        func extractString(from input: String) -> String {
+            // Check if the input string starts with "(" or ends with ")"
+            if input.hasPrefix("(") {
+                let startIndex = input.index(input.startIndex, offsetBy: 1)
+                let result = input[startIndex..<input.endIndex]
+                return String(result)
+            } else if input.hasSuffix(")") {
+                let endIndex = input.index(input.endIndex, offsetBy: -1)
+                let result = input[input.startIndex..<endIndex]
+                return String(result)
+            } else {
+                return input
+            }
+        }
+        func removeOperatorsAndFollowing(from input: String) -> String {
+            let operatorsPattern = "(=|<=|<|>|>=|<>)"
+            if let range = input.range(of: operatorsPattern, options: .regularExpression) {
+                let result = input.prefix(upTo: range.lowerBound)
+                return String(result)
+            } else {
+                return input // Return the input string unchanged if no operator is found
+            }
+        }
 
-        for token in tokens {
-            if token == "IN" {
+        func processToken(_ token: String) {
+            if token.uppercased() == "IN" {
                 inClause = true
-            } else if inClause && token == "(" {
+            } else if inClause && (token.prefix(7).uppercased() == "(VALUES" ||
+                                    token.prefix(8).uppercased() == "( VALUES") {
                 inValues = true
-            } else if inValues && token == ")" {
+            } else if inValues && (token.suffix(2).uppercased() == "))" ||
+                                    token.suffix(3).uppercased() == ") )") {
                 inValues = false
+            } else if inClause && !inValues && token.prefix(1) == "(" {
+                inPar = true
+            } else if inClause && !inValues && token.suffix(1) == ")" {
+                inPar = false
+                inClause = false
+            } else if token.uppercased() == "BETWEEN" {
+                betweenClause = true
+            } else if betweenClause && token.uppercased() == "AND" {
+                andClause = true
+            } else if operators.contains(token) {
+                inOper = true
+            } else if token.uppercased() == "LIKE" {
+                inLike = true
             } else if token.range(of: "\\b[a-zA-Z]\\w*\\b", options: .regularExpression) != nil
-                        && !inValues && !keywords.contains(token.uppercased()) {
-                columns.append(token)
+                        && !inClause && (!inValues || !inPar)
+                        && !betweenClause && !andClause && !inOper && !inLike
+                        && !keywords.contains(token.uppercased()) {
+                var mToken = extractString(from: token)
+                mToken = removeOperatorsAndFollowing(from: mToken)
+                columns.append(mToken)
+            } else if token.range(of: "\\b[a-zA-Z]\\w*\\b", options: .regularExpression) != nil
+                        && betweenClause && andClause {
+                betweenClause = false
+                andClause = false
+            } else if token.range(of: "\\b[a-zA-Z]\\w*\\b", options: .regularExpression) != nil
+                        && inOper {
+                inOper = false
+            } else if token.range(of: "\\b[a-zA-Z]\\w*\\b", options: .regularExpression) != nil
+                        && inLike {
+                inLike = false
             }
         }
-
-        return Array(Set(columns))
+        let tokens = whereClause.components(separatedBy: CharacterSet(charactersIn: " ,"))
+        for token in tokens {
+            processToken(token)
+        }
+        return Array(columns)
     }
+    // swiftlint:enable function_body_length
 
     // MARK: - flattenMultilineString
 
@@ -308,11 +371,12 @@ class UtilsSQLStatement {
 
         for match in matches {
 
-            let keysRange = Range(match.range(at: 1), in: whereClause)!
-            let keysString = String(whereClause[keysRange])
-            let keys = keysString.split(separator: ",").map {
-                String($0.trimmingCharacters(in: .whitespaces)) }
-            primaryKeySets.append(keys)
+            if let keysRange = Range(match.range(at: 1), in: whereClause) {
+                let keysString = String(whereClause[keysRange])
+                let keys = keysString.split(separator: ",").map {
+                    String($0.trimmingCharacters(in: .whitespaces)) }
+                primaryKeySets.append(keys)
+            }
         }
         return primaryKeySets.isEmpty ? nil : primaryKeySets
     }

package/ios/Plugin/Utils/UtilsSecret.swift

@@ -255,6 +255,7 @@ class UtilsSecret {
             if !getPassphrase(account: account).isEmpty {
                 try setPassphrase(account: account, passphrase: "")
             }
+
         } catch UtilsSecretError.setPassphrase(let message) {
             throw UtilsSecretError.clearEncryptionSecret(message: message)
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor-community/sqlite",
-  "version": "5.2.3",
+  "version": "5.2.4",
   "description": "Community plugin for native & electron SQLite databases",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -69,7 +69,7 @@
     "@ionic/swiftlint-config": "^1.1.2",
     "@rollup/plugin-commonjs": "^20.0.0",
     "@rollup/plugin-node-resolve": "^13.0.4",
-    "electron": "^22.0.0",
+    "electron": "^25.2.0",
     "eslint": "^7.11.0",
     "prettier": "~2.3.0",
     "prettier-plugin-java": "~1.0.2",
@@ -98,6 +98,6 @@
     }
   },
   "dependencies": {
-    "jeep-sqlite": "^2.5.1"
+    "jeep-sqlite": "^2.5.3"
   }
 }