@capacitor-community/sqlite 5.7.2 → 5.7.3-2

package/ios/Plugin/CapacitorSQLite.swift

@@ -589,12 +589,9 @@ enum CapacitorSQLiteError: Error {
                 self.retHandler.rResult(call: call)
                 return
             case .failure(let error):
-
-                if error == .downloadFromHTTPFailed {
-                    let msg = "Download from HTTP failed"
-                    self.retHandler.rResult(call: call, message: msg)
-                    return
-                }
+                let msg = "Download from HTTP failed: \(error.localizedDescription)"
+                self.retHandler.rResult(call: call, message: msg)
+                return
 
             }
 
@@ -1013,6 +1010,7 @@ enum CapacitorSQLiteError: Error {
     // MARK: - deleteDatabase
 
     // swiftlint:disable cyclomatic_complexity
+    // swiftlint:disable function_body_length
     @objc func deleteDatabase(_ dbName: String, readonly: Bool) throws {
         guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
@@ -1030,10 +1028,12 @@ enum CapacitorSQLiteError: Error {
         do {
             if !mDb.isDBOpen() {
                 // check the state of the DB
-                let state: State = UtilsSQLCipher.getDatabaseState(databaseLocation: databaseLocation, databaseName: "\(mDbName)SQLite.db", account: account)
-                if !isEncryption && 
-                        (state.rawValue == "ENCRYPTEDGLOBALSECRET" ||
-                         state.rawValue == "ENCRYPTEDSECRET") {
+                let state: State = UtilsSQLCipher.getDatabaseState(databaseLocation: databaseLocation,
+                                                                   databaseName: "\(mDbName)SQLite.db",
+                                                                   account: account)
+                if !isEncryption &&
+                    (state.rawValue == "ENCRYPTEDGLOBALSECRET" ||
+                    state.rawValue == "ENCRYPTEDSECRET") {
                     var msg = "Cannot delete an Encrypted database with "
                     msg += "No Encryption set in capacitor.config"
                     throw CapacitorSQLiteError.failed(message: msg)
@@ -1066,6 +1066,7 @@ enum CapacitorSQLiteError: Error {
             throw CapacitorSQLiteError.failed(message: msg)
         }
     }
+    // swiftlint:enable function_body_length
     // swiftlint:enable cyclomatic_complexity
 
     // MARK: - isJsonValid
@@ -1547,7 +1548,7 @@ enum CapacitorSQLiteError: Error {
             // get the database files
             let dbList: [String] = try UtilsFile.getFileList(path: aPath, ext: ".db")
             // filter for db including SQLite
-            let dbWithSQLite = dbList.filter { $0.contains("SQLite") }
+            let dbWithSQLite = dbList.filter({ $0.contains("SQLite") })
 
             return dbWithSQLite
 
@@ -1567,7 +1568,7 @@ enum CapacitorSQLiteError: Error {
             let dbList: [String] = try UtilsMigrate
                 .getMigratableList(folderPath: folderPath)
             // filter for db not including SQLite
-            let dbNoSQLite = dbList.filter { !$0.contains("SQLite") }
+            let dbNoSQLite = dbList.filter({ !$0.contains("SQLite") })
 
             return dbNoSQLite
 

package/ios/Plugin/CapacitorSQLitePlugin.swift

@@ -1369,14 +1369,13 @@ public class CapacitorSQLitePlugin: CAPPlugin {
                 implementation?.addUpgradeStatement(dbName,
                                                     upgrade: upgrade) {
                 if
-                    versionUpgrades[dbName] != nil {
+                    self.versionUpgrades["\(dbName)"] != nil {
                     for (versionKey, upgObj) in upgVersionDict {
-                        versionUpgrades[dbName]?[versionKey] = upgObj
+                        self.versionUpgrades["\(dbName)"]?[versionKey] = upgObj
                     }
                 } else {
-                    versionUpgrades = ["\(dbName)": upgVersionDict]
+                    self.versionUpgrades["\(dbName)"] = upgVersionDict
                 }
-
                 retHandler.rResult(call: call)
                 return
             } else {
@@ -1542,29 +1541,25 @@ public class CapacitorSQLitePlugin: CAPPlugin {
                 message: "GetFromHTTPRequest: Must provide a database url")
             return
         }
-        DispatchQueue.global(qos: .background).async {
+        DispatchQueue.global(qos: .background).async(execute: {
             do {
                 try self.implementation?.getFromHTTPRequest(call, url: url)
-                DispatchQueue.main.async {
-                    self.retHandler.rResult(call: call)
-                    return
-                }
             } catch CapacitorSQLiteError.failed(let message) {
 
-                DispatchQueue.main.async {
+                DispatchQueue.main.async(execute: {
                     let msg = "GetFromHTTPRequest: \(message)"
                     self.retHandler.rResult(call: call, message: msg)
                     return
-                }
+                })
             } catch let error {
-                DispatchQueue.main.async {
+                DispatchQueue.main.async(execute: {
                     let msg = "GetFromHTTPRequest: " +
                         "\(error.localizedDescription)"
                     self.retHandler.rResult(call: call, message: msg)
                     return
-                }
+                })
             }
-        }
+        })
 
     }
 

package/ios/Plugin/Utils/UtilsBinding.swift

@@ -84,10 +84,9 @@ class UtilsBinding {
     // swiftlint:enable cyclomatic_complexity
     class func extractSortedValues(from queryValues: [String: Int]) -> [UInt8] {
         // Extract keys and sort them
-        let sortedKeys = queryValues.keys.sorted { $0.localizedStandardCompare($1) == .orderedAscending }
-
+        let sortedKeys = queryValues.keys.sorted { $0.localizedStandardCompare($1) == .orderedAscending}
         // Extract corresponding values and sort them based on keys
-        let sortedValues = sortedKeys.compactMap { UInt8(queryValues[$0] ?? 0) }
+        let sortedValues = sortedKeys.compactMap({ UInt8(queryValues[$0] ?? 0) })
 
         return sortedValues
     }

package/ios/Plugin/Utils/UtilsDelete.swift

@@ -289,19 +289,19 @@ class UtilsDelete {
     throws -> (String, [[String: Any]]) {
         var relatedItems: [[String: Any]] = []
         var key: String = ""
-        let t1Names = withRefsNames.map { "t1.\($0)" }
-        let t2Names = colNames.map { "t2.\($0)" }
+        let t1Names = withRefsNames.map({ "t1.\($0)" })
+        let t2Names = colNames.map({ "t2.\($0)"})
 
         do {
             var whereClause = try UtilsSQLStatement
                 .addPrefixToWhereClause(whStmt, from: colNames,
-                                        to: withRefsNames,
+                                        destination: withRefsNames,
                                         prefix: "t2.")
             if whereClause.hasSuffix(";") {
                 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) " +
@@ -312,9 +312,12 @@ class UtilsDelete {
                 if let mVals = vals[0]["ios_columns"] as? [String] {
                     key = mVals[0]
                     let keyToRemove = "ios_columns"
-                    vals.removeAll { dict in
+
+                    // Remove dictionaries where the keys contain "ios_columns"
+                    vals.removeAll { (dict: [String: Any]) in
                         return dict.keys.contains(keyToRemove)
                     }
+                    // Append the remaining dictionaries to relatedItems
                     for val in vals {
                         relatedItems.append(val)
                     }
@@ -440,9 +443,15 @@ class UtilsDelete {
                 .firstMatch(in: statement, options: [],
                             range: NSRange(location: 0,
                                            length: statement.utf16.count)) {
-                let tableNameRange = Range(tableNameMatch.range(
-                                            at: 1), in: statement)!
-                tableName = String(statement[tableNameRange])
+                if let tableNameRange = Range(tableNameMatch.range(at: 1), in: statement) {
+                    tableName = String(statement[tableNameRange])
+                } else {
+                    let msg = "getRefs: Error creating tableNameRange "
+                    throw UtilsDeleteError.getRefs(message: msg)
+                }
+            } else {
+                    let msg = "getRefs: Error creating tableNameMatch "
+                    throw UtilsDeleteError.getRefs(message: msg)
             }
 
             // Regular expression pattern to match the FOREIGN KEY
@@ -458,10 +467,14 @@ class UtilsDelete {
                          range: NSRange(location: 0,
                                         length: statement.utf16.count))
             for foreignKeyMatch in foreignKeyMatches {
-                let foreignKeyRange = Range(
-                    foreignKeyMatch.range(at: 0), in: statement)!
-                let foreignKey = String(statement[foreignKeyRange])
-                foreignKeys.append(foreignKey)
+                if let foreignKeyRange = Range(
+                    foreignKeyMatch.range(at: 0), in: statement) {
+                    let foreignKey = String(statement[foreignKeyRange])
+                    foreignKeys.append(foreignKey)
+                } else {
+                    let msg = "getRefs: Error creating foreignKeyRange "
+                    throw UtilsDeleteError.getRefs(message: msg)
+                }
             }
         } catch {
             let msg = "getRefs: Error creating regular expression: " +

package/ios/Plugin/Utils/UtilsDownloadFromHTTP.swift

@@ -9,114 +9,184 @@ import Foundation
 import ZIPFoundation
 
 enum UtilsDownloadError: Error {
-    case downloadFromHTTPFailed
+    case downloadFromHTTPFailed(message: String)
+    case fileNotFound(message: String)
+    case fileMoveFailed(message: String)
+    case fileExtractionFailed(message: String)
+    case invalidArchive(message: String)
 }
+
 class UtilsDownloadFromHTTP {
-    // swiftlint:disable cyclomatic_complexity
-    // swiftlint:disable function_body_length
+
     class func download(databaseLocation: String, url: String,
-                        completion: @escaping (Result<Bool, UtilsDownloadError>)
-                            -> Void) {
-        if let mUrl: URL = URL(string: url) {
-            let fileName = mUrl.lastPathComponent
-            var dbName = fileName
-            var isZip = false
-            if !fileName.contains("SQLite.db") {
-                if String(fileName.suffix(3)) == ".db" {
-                    dbName = fileName.replacingOccurrences(
-                        of: ".db", with: "SQLite.db")
-                }
-                if String(fileName.suffix(4)) == ".zip" {
-                    isZip = true
+                        completion: @escaping (Result<Bool, UtilsDownloadError>) -> Void) {
+        guard let fileDetails = getFileDetails(url: url),
+            let fileExtension = fileDetails.extension ,
+            fileExtension == "db" || fileExtension == "zip" else {
+            let msg = "download: Not a .zip or .db url"
+            print("\(msg)")
+            completion(.failure(UtilsDownloadError.downloadFromHTTPFailed(message: msg)))
+            return
+        }
+
+        guard let dbUrl = try? UtilsFile.getDatabaseLocationURL(databaseLocation: databaseLocation) else {
+            let msg = "databaseLocation failed"
+            print("\(msg)")
+            completion(.failure(UtilsDownloadError.downloadFromHTTPFailed(message: msg)))
+            return
+        }
+
+        downloadFile(url: url) { result in
+            switch result {
+            case .success(let cachedFile):
+                if fileExtension == "zip" {
+                    handleZipFile(cachedFile: cachedFile, dbUrl: dbUrl, completion: completion)
+                } else {
+                    handleNonZipFile(cachedFile: cachedFile, dbUrl: dbUrl, completion: completion)
                 }
+            case .failure:
+                let msg = "Failed to download file: "
+                completion(.failure(UtilsDownloadError.downloadFromHTTPFailed(message: msg)))
             }
-            // compute a path to this Url in the cache
-            let cacheURL = UtilsFile.getTmpURL()
-            let tmp = cacheURL.lastPathComponent
-            let fileCacheURL = FileManager.default.temporaryDirectory
-                .appendingPathComponent(
-                    dbName,
-                    isDirectory: false
-                )
-
-            let task = URLSession.shared
-                .downloadTask(with: mUrl) {(tempURL, response, error) in
-                    // Early exit on error
-                    guard let tempURL = tempURL else {
-                        let msg = "\(String(describing: error?.localizedDescription))"
-                        print("\(msg)")
-                        completion(.failure(UtilsDownloadError.downloadFromHTTPFailed))
+        }
+    }
+
+    class func handleZipFile(cachedFile: URL, dbUrl: URL, completion: @escaping (Result<Bool, UtilsDownloadError>) -> Void) {
+        extractDBFiles(from: cachedFile) { dbFiles, error in
+            if let error = error {
+                let msg = "\(error.localizedDescription)"
+                completion(.failure(UtilsDownloadError.downloadFromHTTPFailed(message: msg)))
+            } else {
+                for file in dbFiles {
+                    if let moveError = moveAndRenameFile(from: file, to: dbUrl) {
+                        let msg = "Failed to move file: \(moveError.localizedDescription)"
+                        completion(.failure(UtilsDownloadError.downloadFromHTTPFailed(message: msg)))
                         return
                     }
-                    if let httpResponse = response as? HTTPURLResponse {
-                        switch httpResponse.statusCode {
-                        case 200:
-                            do {
-                                // Remove any existing document at file
-                                if FileManager.default.fileExists(
-                                    atPath: fileCacheURL.path) {
-                                    try FileManager.default.removeItem(
-                                        atPath: fileCacheURL.path)
-                                }
-
-                                // Copy the tempURL to file
-                                try FileManager.default.copyItem(
-                                    at: tempURL,
-                                    to: fileCacheURL
-                                )
-                                // Delete the tempUrl file
-                                try FileManager.default.removeItem(at: tempURL)
-                                let dbURL = try UtilsFile.getDatabaseLocationURL(
-                                    databaseLocation: databaseLocation)
-                                if isZip {
-                                    // get the zip files
-                                    let zipList: [String] = try UtilsFile
-                                        .getFileList(path: cacheURL.path,
-                                                     ext: ".zip")
-                                    // loop through the database files
-                                    for zip in zipList {
-                                        _ = try UtilsFile.unzipToDatabase(
-                                            fromURL: cacheURL,
-                                            databaseLocation: tmp,
-                                            zip: zip,
-                                            overwrite: true)
-                                    }
-                                    // Delete the zip file
-                                    try FileManager.default.removeItem(
-                                        at: fileCacheURL)
-
-                                }
-                                try UtilsFile.moveAllDBSQLite(
-                                    fromURL: cacheURL,
-                                    dirUrl: dbURL)
-                                completion(.success(true))
-                                return
-                            }
-
-                            // Handle potential file system errors
-                            catch let error {
-                                let msg = "\(error.localizedDescription)"
-                                print("\(msg)")
-                                completion(.failure(UtilsDownloadError.downloadFromHTTPFailed))
-                                return
-                            }
-                        default:
-                            let msg = "Download: GET resquest not successful. http status code \(httpResponse.statusCode)"
-                            print("\(msg)")
-                            completion(.failure(UtilsDownloadError.downloadFromHTTPFailed))
-                            return
-                        }
-                    } else {
-                        let msg = "Download: not a valid http response"
-                        print("\(msg)")
-                        completion(.failure(UtilsDownloadError.downloadFromHTTPFailed))
+                }
+                completion(.success(true))
+            }
+        }
+    }
+
+    class func handleNonZipFile(cachedFile: URL, dbUrl: URL, completion: @escaping (Result<Bool, UtilsDownloadError>) -> Void) {
+        if let moveError = moveAndRenameFile(from: cachedFile, to: dbUrl) {
+            let msg = "Failed to move file: \(moveError.localizedDescription)"
+            completion(.failure(UtilsDownloadError.downloadFromHTTPFailed(message: msg)))
+        } else {
+            completion(.success(true))
+        }
+    }
+
+    class func getFileDetails(url: String) -> (filename: String, extension: String?)? {
+        guard let fileURL = URL(string: url) else { return nil }
+        let filename = fileURL.lastPathComponent
+        let ext = fileURL.pathExtension
+        return (filename, ext.isEmpty ? nil : ext)
+    }
+
+    class func downloadFile(url: String, completion: @escaping (Result<URL, Error>) -> Void) {
+        guard let fileURL = URL(string: url) else { return }
+
+        URLSession.shared.downloadTask(with: fileURL) { (location, _, error) in
+            if let location = location {
+                let tmpURL = UtilsFile.getTmpURL()
+                let suggestedFilename = fileURL.lastPathComponent
+
+                // Construct the destination URL
+                let destinationURL = tmpURL.appendingPathComponent(suggestedFilename)
+
+                // Check if the destination file already exists
+                if FileManager.default.fileExists(atPath: destinationURL.path) {
+                    // Remove the existing file
+                    do {
+                        try FileManager.default.removeItem(at: destinationURL)
+                    } catch {
+                        completion(.failure(error))
                         return
                     }
                 }
-            // Start the download
-            task.resume()
+
+                do {
+                    try FileManager.default.moveItem(at: location, to: destinationURL)
+                    completion(.success(destinationURL))
+                } catch {
+                    print("Moving file \(error.localizedDescription)")
+                    completion(.failure(error))
+                }
+            } else if let error = error {
+                print("Location file \(error.localizedDescription)")
+                completion(.failure(error))
+            }
+
+        }.resume()
+    }
+
+    class func moveAndRenameFile(from sourceURL: URL, to dbURL: URL) -> Error? {
+        let fileManager = FileManager.default
+
+        do {
+            let destinationURL = dbURL.appendingPathComponent(sourceURL.lastPathComponent).absoluteURL
+
+            // Ensure the destination directory exists
+            try fileManager.createDirectory(at: dbURL, withIntermediateDirectories: true, attributes: nil)
+            // Check if the destination file already exists and delete it if necessary
+            if fileManager.fileExists(atPath: destinationURL.path) {
+                try fileManager.removeItem(at: destinationURL)
+            }
+
+            // Move the file to the destination URL
+            try fileManager.moveItem(at: sourceURL, to: destinationURL)
+
+            // Rename the file if needed
+            let lastPathComponent = destinationURL.lastPathComponent
+            if lastPathComponent.hasSuffix(".db") && !lastPathComponent.contains("SQLite") {
+                let newLastPathComponent = lastPathComponent.replacingOccurrences(of: ".db", with: "SQLite.db")
+                let newDestinationURL = dbURL.appendingPathComponent(newLastPathComponent)
+                // Check if the destination file already exists and delete it if necessary
+                if fileManager.fileExists(atPath: newDestinationURL.path) {
+                    try fileManager.removeItem(at: newDestinationURL)
+                }
+
+                try fileManager.moveItem(at: destinationURL, to: newDestinationURL)
+            }
+
+            return nil
+        } catch {
+            return error
         }
     }
-    // swiftlint:enable cyclomatic_complexity
-    // swiftlint:enable function_body_length
+
+    class func extractDBFiles(from zipFile: URL, completion: @escaping ([URL], Error?) -> Void) {
+        DispatchQueue.global().async(execute: {
+            var dbFiles: [URL] = []
+
+            do {
+                let destinationURL = zipFile.deletingLastPathComponent()
+
+                guard let archive = Archive(url: zipFile, accessMode: .read) else {
+                    let msg = "Failed in reading Archive"
+                    completion([], UtilsDownloadError.invalidArchive(message: msg))
+                    return
+                }
+
+                for entry in archive where entry.type == .file {
+                    let fileURL = destinationURL.appendingPathComponent(entry.path)
+                    let fileExtension = URL(fileURLWithPath: entry.path).pathExtension
+
+                    if fileExtension == "db" {
+                        _ = try archive.extract(entry, to: fileURL)
+                        dbFiles.append(fileURL)
+                    }
+                }
+                // Delete the zip file
+                try FileManager.default.removeItem(at: zipFile)
+
+                completion(dbFiles, nil)
+            } catch {
+                completion([], error)
+            }
+        })
+
+    }
 }

package/ios/Plugin/Utils/UtilsJson.swift

@@ -569,9 +569,9 @@ class UtilsJson {
         let iterations: UInt32 = 10000
         var derivedKeyData = Data(count: keyLength)
         let derivedCount = derivedKeyData.count
-        let derivationStatus = derivedKeyData.withUnsafeMutableBytes { derivedKeyUnsafeMutableRawBufferPointer in
-            passphraseData.withUnsafeBytes { passphraseUnsafeRawBufferPointer in
-                salt.withUnsafeBytes { saltUnsafeRawBufferPointer in
+        let derivationStatus = derivedKeyData.withUnsafeMutableBytes({ derivedKeyUnsafeMutableRawBufferPointer in
+            passphraseData.withUnsafeBytes({ passphraseUnsafeRawBufferPointer in
+                salt.withUnsafeBytes({ saltUnsafeRawBufferPointer in
                     CCKeyDerivationPBKDF(
                         CCPBKDFAlgorithm(kCCPBKDF2),
                         passphraseUnsafeRawBufferPointer.baseAddress,
@@ -583,9 +583,9 @@ class UtilsJson {
                         derivedKeyUnsafeMutableRawBufferPointer.baseAddress,
                         derivedCount
                     )
-                }
-            }
-        }
+                })
+            })
+        })
         return derivationStatus == kCCSuccess ? derivedKeyData : nil
     }
 }

package/ios/Plugin/Utils/UtilsSQLCipher.swift

@@ -468,7 +468,7 @@ class UtilsSQLCipher {
                 retMode = "wA\(retMode)"
             }
         }
-        if (retMode == "no" || retMode.prefix(2) == "wA") {
+        if retMode == "no" || retMode.prefix(2) == "wA" {
             let stmtNames = UtilsSQLStatement
                 .getStmtAndRetColNames(sqlStmt: sqlStmt,
                                        retMode: retMode)
@@ -845,7 +845,7 @@ class UtilsSQLCipher {
     }
 
     // MARK: - dbLastId
-    
+
     class func dbLastId(mDB: OpaquePointer?) -> Int64 {
         return Int64(sqlite3_last_insert_rowid(mDB))
     }
@@ -1015,12 +1015,12 @@ class UtilsSQLCipher {
         var mRespSet = respSet
         if !retResponse.isEmpty {
             let keysInArray1 = ["ios_columns"]
-            mRespSet = mRespSet.filter { dict2 in
+            mRespSet = mRespSet.filter({ dict2 in
                 guard let dict2Key = dict2.keys.first else {
                     return true // Keep dictionaries without any keys
                 }
                 return !keysInArray1.contains(dict2Key)
-            }
+            })
         }
         retResponse.append(contentsOf: mRespSet)