@capacitor-community/sqlite 4.1.1 → 4.2.1

package/ios/Plugin/CapacitorSQLite.swift

@@ -10,6 +10,7 @@ enum CapacitorSQLiteError: Error {
     private var config: SqliteConfig
     private var dbDict: [String: Database] = [:]
     private var databaseLocation: String = "Documents"
+    private let retHandler: ReturnHandler = ReturnHandler()
     private var initMessage: String = ""
     private var isInit: Bool = false
     private var isEncryption: Bool = true
@@ -457,6 +458,33 @@ enum CapacitorSQLiteError: Error {
         }
     }
 
+    // MARK: - GetFromHTTPRequest
+
+    @objc public func getFromHTTPRequest(_ call: CAPPluginCall, url: String) throws {
+        if isInit {
+
+            UtilsDownloadFromHTTP.download(databaseLocation: databaseLocation,
+                                           url: url) { ( result) in
+                switch result {
+                case .success(_):
+                    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
+                    }
+
+                }
+
+            }
+        } else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+    }
+
     // MARK: - Close Connection
 
     @objc public func closeConnection(_ dbName: String, readonly: Bool) throws {
@@ -1246,9 +1274,9 @@ enum CapacitorSQLiteError: Error {
 
             // check if the assets/database folder exists
             do {
-                let assetsDbPath: URL = try
+                let assetsDbURL: URL = try
                     UtilsFile.getAssetsDatabasesPath()
-                let aPath: String = assetsDbPath.path
+                let aPath: String = assetsDbURL.path
                 let bRes: Bool = UtilsFile.isDirExist(dirPath: aPath)
                 if bRes {
                     // get the database files from assets
@@ -1274,9 +1302,11 @@ enum CapacitorSQLiteError: Error {
                     for zip in zipList {
                         // for each zip uncompress the file to the Application
                         // database folder
-                        _ = try UtilsFile
-                            .unzipFromAssetToDatabase(databaseLocation: databaseLocation,
-                                                      zip: zip, overwrite: overwrite)
+                        _ = try UtilsFile.unzipToDatabase(
+                            fromURL: assetsDbURL,
+                            databaseLocation: databaseLocation,
+                            zip: zip,
+                            overwrite: overwrite)
                     }
                     return
                 } else {
@@ -1285,7 +1315,7 @@ enum CapacitorSQLiteError: Error {
                 }
             } catch UtilsFileError.copyFromAssetToDatabaseFailed(let message) {
                 throw CapacitorSQLiteError.failed(message: message)
-            } catch UtilsFileError.unzipFromAssetToDatabaseFailed(let message) {
+            } catch UtilsFileError.unzipToDatabaseFailed(let message) {
                 throw CapacitorSQLiteError.failed(message: message)
             } catch let error {
                 let msg: String = "\(error)"

package/ios/Plugin/CapacitorSQLitePlugin.swift

@@ -1158,11 +1158,10 @@ public class CapacitorSQLitePlugin: CAPPlugin {
             if let upgVersionDict: [Int: [String: Any]] = try
                 implementation?.addUpgradeStatement(dbName,
                                                     upgrade: upgrade) {
-                if (
-                    versionUpgrades[dbName] != nil
-                ){
+                if
+                    versionUpgrades[dbName] != nil {
                     for (versionKey, upgObj) in upgVersionDict {
-                        versionUpgrades[dbName]![versionKey] = upgObj
+                        versionUpgrades[dbName]?[versionKey] = upgObj
                     }
                 } else {
                     versionUpgrades = ["\(dbName)": upgVersionDict]
@@ -1323,13 +1322,42 @@ public class CapacitorSQLitePlugin: CAPPlugin {
         }
 
     }
-    
+
     // MARK: - GetFromHTTPRequest
 
     @objc func getFromHTTPRequest(_ call: CAPPluginCall) {
-        call.unimplemented("Not implemented on iOS.")
-    }
+        guard let url = call.options["url"] as? String else {
+            retHandler.rResult(
+                call: call,
+                message: "GetFromHTTPRequest: Must provide a database url")
+            return
+        }
+        DispatchQueue.global(qos: .background).async {
+
+            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 {
+                    let msg = "GetFromHTTPRequest: \(message)"
+                    self.retHandler.rResult(call: call, message: msg)
+                    return
+                }
+            } catch let error {
+                DispatchQueue.main.async {
+                    let msg = "GetFromHTTPRequest: " +
+                        "\(error.localizedDescription)"
+                    self.retHandler.rResult(call: call, message: msg)
+                    return
+                }
+            }
+        }
+
+    }
 
     // MARK: - Add Observers
 
@@ -1380,31 +1408,28 @@ public class CapacitorSQLitePlugin: CAPPlugin {
         config.iosIsEncryption = 1
         config.biometricAuth = 0
         config.iosKeychainPrefix = ""
-        if let keychainPrefix = getConfigValue("iosKeychainPrefix") as? String {
+        let configPlugin = getConfig()
+        if let keychainPrefix = configPlugin.getString("iosKeychainPrefix") {
             config.iosKeychainPrefix = keychainPrefix
         }
-        if let iosDatabaseLocation = getConfigValue("iosDatabaseLocation")
-            as? String {
+        if let iosDatabaseLocation = configPlugin.getString("iosDatabaseLocation") {
             config.iosDatabaseLocation = iosDatabaseLocation
         }
-        if let isEncryption = getConfigValue("iosIsEncryption") as? Bool {
-            if !isEncryption {
-                config.iosIsEncryption = 0
-            }
+        let isEncryption = configPlugin.getBoolean("iosIsEncryption", false)
+        if !isEncryption {
+            config.iosIsEncryption = 0
         }
         if config.iosIsEncryption == 1 {
-            if let iosBiometric = getConfigValue("iosBiometric") as? [String: Any] {
-                if let bioAuth = iosBiometric["biometricAuth"] as? Bool {
-                    if bioAuth {
-                        config.biometricAuth = 1
-                        if let bioTitle = iosBiometric["biometricTitle"] as? String {
-                            config.biometricTitle = bioTitle.count > 0
-                                ? bioTitle
-                                : "Biometric login for capacitor sqlite"
-                        }
+            let iosBiometric = configPlugin.getObject("iosBiometric")
+            if let bioAuth = iosBiometric?["biometricAuth"] as? Bool {
+                if bioAuth {
+                    config.biometricAuth = 1
+                    if let bioTitle = iosBiometric?["biometricTitle"] as? String {
+                        config.biometricTitle = bioTitle.count > 0
+                            ? bioTitle
+                            : "Biometric login for capacitor sqlite"
                     }
                 }
-
             }
         }
         return config

package/ios/Plugin/Utils/UtilsDownloadFromHTTP.swift

@@ -0,0 +1,122 @@
+//
+//  UtilsDownloadFromHTTP.swift
+//  CapacitorCommunitySqlite
+//
+//  Created by  Quéau Jean Pierre on 05/10/2022.
+//
+
+import Foundation
+import ZIPFoundation
+
+enum UtilsDownloadError: Error {
+    case downloadFromHTTPFailed
+}
+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
+                }
+            }
+            // 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))
+                    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))
+                    return
+                }
+            }
+            // Start the download
+            task.resume()
+        }
+    }
+    // swiftlint:enable cyclomatic_complexity
+    // swiftlint:enable function_body_length
+}

package/ios/Plugin/Utils/UtilsFile.swift

@@ -25,12 +25,13 @@ enum UtilsFileError: Error {
     case getLibraryURLFailed
     case getFileListFailed
     case copyFromAssetToDatabaseFailed(message: String)
-    case unzipFromAssetToDatabaseFailed(message: String)
+    case unzipToDatabaseFailed(message: String)
     case copyFromNamesFailed
     case getFolderURLFailed(message: String)
     case createDirFailed(message: String)
     case moveAllDBSQLiteFailed(message: String)
     case createDatabaseLocationFailed(message: String)
+    case getDatabaseLocationURLFailed(message: String)
 }
 // swiftlint:disable file_length
 // swiftlint:disable type_body_length
@@ -51,12 +52,17 @@ class UtilsFile {
                 // move all existing dbs from "Documents" to location folder
                 if location.prefix(9) != "Documents" &&
                     location.prefix(7) != "default" {
+                    let databaseURL: URL = try UtilsFile
+                        .getDatabasesUrl().absoluteURL
 
-                    try UtilsFile.moveAllDBSQLite(dirUrl: dirUrl)
+                    try UtilsFile.moveAllDBSQLite(fromURL: databaseURL,
+                                                  dirUrl: dirUrl)
                 }
             }
         } catch UtilsFileError.getFolderURLFailed(let message) {
             throw UtilsFileError.createDatabaseLocationFailed(message: message)
+        } catch UtilsFileError.getDatabasesURLFailed {
+            throw UtilsFileError.createDatabaseLocationFailed(message: "getDatabasesURLFailed")
         } catch UtilsFileError.moveAllDBSQLiteFailed(let message) {
             throw UtilsFileError.createDatabaseLocationFailed(message: message)
         } catch let error {
@@ -77,16 +83,15 @@ class UtilsFile {
 
     // MARK: - moveAllDBSQLite
 
-    class func moveAllDBSQLite(dirUrl: URL) throws {
+    class func moveAllDBSQLite(fromURL: URL, dirUrl: URL) throws {
         // get the db list from Documents folder
         do {
-            let databaseURL: URL = try UtilsFile
-                .getDatabasesUrl().absoluteURL
+
             let fileList: [String] = try UtilsFile
-                .getFileList(path: databaseURL.path,
+                .getFileList(path: fromURL.path,
                              ext: "SQLite.db")
             for file in fileList {
-                let fromFileURL: URL = databaseURL
+                let fromFileURL: URL = fromURL
                     .appendingPathComponent(file).absoluteURL
                 let toFileURL = dirUrl
                     .appendingPathComponent(file).absoluteURL
@@ -149,6 +154,8 @@ class UtilsFile {
                 dbPathURL = try UtilsFile.getApplicationURL().absoluteURL
             } else if first[0] == "Library" {
                 dbPathURL = try UtilsFile.getLibraryURL().absoluteURL
+            } else if first[0] == "tmp" {
+                dbPathURL = UtilsFile.getTmpURL().absoluteURL
             } else if first[0].caseInsensitiveCompare("cache") == .orderedSame {
                 dbPathURL = try UtilsFile.getCacheURL().absoluteURL
             } else if first[0] == "Documents" || first[0] == "default" {
@@ -216,6 +223,19 @@ class UtilsFile {
         }
     }
 
+    // MARK: - getDatabaseLocationURL
+
+    class func getDatabaseLocationURL(databaseLocation: String) throws -> URL {
+        do {
+            let url: URL = try UtilsFile
+                .getFolderURL(folderPath: databaseLocation)
+
+            return url
+        } catch UtilsFileError.getFolderURLFailed(let message) {
+            throw UtilsFileError.getDatabaseLocationURLFailed(message: message)
+        }
+    }
+
     // MARK: - getApplicationURL
 
     class func getApplicationURL() throws -> URL {
@@ -255,6 +275,12 @@ class UtilsFile {
         }
     }
 
+    // MARK: - getTmpURL
+
+    class func getTmpURL() -> URL {
+        return FileManager.default.temporaryDirectory
+    }
+
     // MARK: - getLibraryURL
 
     class func getLibraryURL() throws -> URL {
@@ -395,15 +421,14 @@ class UtilsFile {
 
     }
 
-    class func unzipFromAssetToDatabase(databaseLocation: String, zip: String,
-                                        overwrite: Bool) throws {
+    class func unzipToDatabase(fromURL: URL, databaseLocation: String, zip: String,
+                               overwrite: Bool) throws {
         do {
-            let zipAsset: URL = try getAssetsDatabasesPath()
-                .appendingPathComponent(zip)
+            let zipAsset: URL = fromURL.appendingPathComponent(zip)
             guard let archive = Archive(url: zipAsset, accessMode: .read) else {
                 let msg = "Error: Read Archive: \(zipAsset) failed"
                 print("\(msg)")
-                throw UtilsFileError.unzipFromAssetToDatabaseFailed(message: msg)
+                throw UtilsFileError.unzipToDatabaseFailed(message: msg)
             }
             let uDb: URL = try getFolderURL(folderPath: databaseLocation)
             for entry in archive {
@@ -421,20 +446,16 @@ class UtilsFile {
                 } catch {
                     let msg = "Error: Extracting \(entry.path) from archive failed \(error.localizedDescription)"
                     print("\(msg)")
-                    throw UtilsFileError.unzipFromAssetToDatabaseFailed(message: msg)
+                    throw UtilsFileError.unzipToDatabaseFailed(message: msg)
                 }
             }
-        } catch UtilsFileError.getAssetsDatabasesPathFailed {
-            let msg = "Error: getAssetsDatabasesPath Failed"
-            print("\(msg)")
-            throw UtilsFileError.unzipFromAssetToDatabaseFailed(message: msg)
         } catch UtilsFileError.getFolderURLFailed(let message) {
             print("Error: getFolderUrl Failed \(message)")
-            throw UtilsFileError.unzipFromAssetToDatabaseFailed(message: message)
+            throw UtilsFileError.unzipToDatabaseFailed(message: message)
         } catch let error {
             let msg = "Error: \(error)"
             print("\(msg)")
-            throw UtilsFileError.unzipFromAssetToDatabaseFailed(message: msg)
+            throw UtilsFileError.unzipToDatabaseFailed(message: msg)
         }
     }
 

package/ios/Plugin/Utils/UtilsMigrate.swift

@@ -238,7 +238,7 @@ class UtilsMigrate {
                         if !toFile.isEmpty {
                             let uFrom: URL = dbPathURL.appendingPathComponent(fromFile)
                             let uTo: URL = databaseURL.appendingPathComponent(toFile)
-                            try UtilsFile.moveFile(pathName: uFrom.path, toPathName: uTo.path, overwrite: true)
+                            _ = try UtilsFile.moveFile(pathName: uFrom.path, toPathName: uTo.path, overwrite: true)
                         }
                     }
                 }

package/ios/Plugin/Utils/UtilsUpgrade.swift

@@ -27,7 +27,7 @@ class UtilsUpgrade {
         for (versionKey, upgrade) in Array(upgDict).sorted(by: {$0.0 < $1.0}) {
             if versionKey > currentVersion && versionKey <= targetVersion {
                 print("- UtilsUpgrade.onUpgrade toVersion: \(versionKey)")
-                
+
                 guard let statements = upgrade["statements"] as? [String] else {
                     let msg: String = "Error: onUpgrade statements not given"
                     throw UtilsUpgradeError.onUpgradeFailed(message: msg)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor-community/sqlite",
-  "version": "4.1.1",
+  "version": "4.2.1",
   "description": "Community plugin for native & electron SQLite databases",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -55,10 +55,10 @@
     "prepublishOnly": "npm run build && npm run build-electron && npm run docgen"
   },
   "devDependencies": {
-    "@capacitor/android": "^4.1.0",
-    "@capacitor/core": "^4.1.0",
+    "@capacitor/android": "^4.2.0",
+    "@capacitor/core": "^4.2.0",
     "@capacitor/docgen": "^0.0.17",
-    "@capacitor/ios": "^4.1.0",
+    "@capacitor/ios": "^4.2.0",
     "@ionic/eslint-config": "^0.3.0",
     "@ionic/prettier-config": "^1.0.1",
     "@ionic/swiftlint-config": "^1.1.2",