@capacitor-community/sqlite 5.0.5-2 → 5.0.6

package/ios/Plugin/ImportExportJson/ImportFromJson.swift

@@ -34,25 +34,24 @@ class ImportFromJson {
 
     // MARK: - ImportFromJson - CreateDatabaseSchema
 
-    class func createDatabaseSchema(mDB: Database,
-                                    jsonSQLite: JsonSQLite)
+    class func createDatabaseSchema(mDB: Database, tables: [ImportTable],
+                                    mode: String, version: Int)
     throws -> Int {
         let msg = "importFromJson: "
         var changes: Int = -1
-        let version: Int = jsonSQLite.version
 
         do {
             // Set PRAGMAS
             try UtilsSQLCipher.setVersion(mDB: mDB,
                                           version: version)
-            if jsonSQLite.mode == "full" {
+            if mode == "full" {
                 // Drop All Tables, Indexes and Triggers
                 try _ = UtilsDrop.dropAll(mDB: mDB)
             }
             // create database schema
             changes = try ImportFromJson
                 .createSchema(mDB: mDB,
-                              jsonSQLite: jsonSQLite)
+                              tables: tables, mode: mode)
             let msg = "Schema creation completed changes: \(changes)"
             notifyImportProgressEvent(msg: msg)
             return changes
@@ -76,8 +75,8 @@ class ImportFromJson {
     // MARK: - ImportFromJson - createSchema
 
     // swiftlint:disable function_body_length
-    class func createSchema(mDB: Database,
-                            jsonSQLite: JsonSQLite) throws -> Int {
+    class func createSchema(mDB: Database, tables: [ImportTable],
+                            mode: String) throws -> Int {
         var changes: Int = 0
         var initChanges: Int = 0
         do {
@@ -88,7 +87,7 @@ class ImportFromJson {
         }
         // Create a Schema Statements
         let statements = ImportFromJson
-            .createSchemaStatement(jsonSQLite: jsonSQLite )
+            .createSchemaStatement(tables: tables, mode: mode )
         if statements.count > 0 {
             let joined = statements.joined(separator: "\n")
             let mStmt: String = joined.replacingOccurrences(of: "\'", with: "'")
@@ -132,7 +131,7 @@ class ImportFromJson {
                 .createSchema(message: message)
             }
         } else {
-            if jsonSQLite.mode == "partial" {
+            if mode == "partial" {
                 changes = 0
                 // Commit the transaction
                 try UtilsSQLCipher.commitTransaction(mDB: mDB)
@@ -144,16 +143,15 @@ class ImportFromJson {
 
     // MARK: - ImportFromJson - createSchemaStatement
 
-    class func createSchemaStatement(jsonSQLite: JsonSQLite)
-    -> [String] {
+    class func createSchemaStatement(tables: [ImportTable],
+                                     mode: String) -> [String] {
         // Create the Database Schema
         var statements: [String] = []
         // Loop through Tables
-        for ipos in 0..<jsonSQLite.tables.count {
-            let mode: String = jsonSQLite.mode
-            let tableName: String = jsonSQLite.tables[ipos].name
-            if let mSchema: [JsonColumn] =
-                jsonSQLite.tables[ipos].schema {
+        for ipos in 0..<tables.count {
+            let mode: String = mode
+            let tableName: String = tables[ipos].name
+            if let mSchema: [ImportColumn] = tables[ipos].schema {
                 if mSchema.count > 0 {
                     let stmt: [String] =
                         ImportFromJson.createTableSchema(
@@ -162,8 +160,7 @@ class ImportFromJson {
                     statements.append(contentsOf: stmt)
                 }
             }
-            if let mIndexes: [JsonIndex] =
-                jsonSQLite.tables[ipos].indexes {
+            if let mIndexes: [ImportIndex] = tables[ipos].indexes {
                 if mIndexes.count > 0 {
                     let stmt: [String] =
                         ImportFromJson.createTableIndexes(
@@ -171,8 +168,7 @@ class ImportFromJson {
                     statements.append(contentsOf: stmt)
                 }
             }
-            if let mTriggers: [JsonTrigger] =
-                jsonSQLite.tables[ipos].triggers {
+            if let mTriggers: [ImportTrigger] = tables[ipos].triggers {
                 if mTriggers.count > 0 {
                     let stmt: [String] =
                         ImportFromJson.createTableTriggers(
@@ -188,7 +184,7 @@ class ImportFromJson {
 
     // swiftlint:disable function_body_length
     // swiftlint:disable cyclomatic_complexity
-    class func createTableSchema(mSchema: [JsonColumn],
+    class func createTableSchema(mSchema: [ImportColumn],
                                  tableName: String, mode: String)
     -> [String] {
         var statements: [String] = []
@@ -251,7 +247,7 @@ class ImportFromJson {
 
     // MARK: - ImportFromJson - CreateTableIndexes
 
-    class func createTableIndexes(mIndexes: [JsonIndex],
+    class func createTableIndexes(mIndexes: [ImportIndex],
                                   tableName: String) -> [String] {
         var statements: [String] = []
         for jpos in 0..<mIndexes.count {
@@ -279,7 +275,7 @@ class ImportFromJson {
 
     // MARK: - ImportFromJson - CreateTableTriggers
 
-    class func createTableTriggers(mTriggers: [JsonTrigger],
+    class func createTableTriggers(mTriggers: [ImportTrigger],
                                    tableName: String) -> [String] {
         var statements: [String] = []
 
@@ -308,8 +304,8 @@ class ImportFromJson {
 
     // swiftlint:disable function_body_length
     class func createDatabaseData(mDB: Database,
-                                  jsonSQLite: JsonSQLite)
-    throws -> Int {
+                                  tables: [ImportTable],
+                                  mode: String) throws -> Int {
         var changes: Int = -1
         var initChanges: Int = -1
         var isValue: Bool = false
@@ -322,19 +318,19 @@ class ImportFromJson {
             throw ImportFromJsonError.createDatabaseData(message: message)
         }
         // Loop on tables to create Data
-        for ipos in 0..<jsonSQLite.tables.count {
-            if let mValues = jsonSQLite.tables[ipos].values {
+        for ipos in 0..<tables.count {
+            if let mValues = tables[ipos].values {
                 if mValues.count > 0 {
                     isValue = true
                     do {
-                        let tableName = jsonSQLite.tables[ipos].name
+                        let tableName = tables[ipos].name
                         try ImportFromJson.createTableData(
                             mDB: mDB,
-                            mode: jsonSQLite.mode,
+                            mode: mode,
                             mValues: mValues,
                             tableName: tableName)
                         let msg = "Table \(tableName) data creation completed " +
-                            "\(ipos + 1)/\(jsonSQLite.tables.count) ..."
+                            "\(ipos + 1)/\(tables.count) ..."
                         notifyImportProgressEvent(msg: msg)
 
                     } catch ImportFromJsonError
@@ -382,8 +378,9 @@ class ImportFromJson {
     // swiftlint:disable function_body_length
     class func createTableData(
         mDB: Database, mode: String,
-        mValues: [[UncertainValue<String, Int, Double>]],
+        mValues: [[Any]],
         tableName: String) throws {
+        var lastId: Int64 = -1
         // Check if table exists
         do {
             let isTab: Bool = try UtilsJson
@@ -409,8 +406,7 @@ class ImportFromJson {
         }
         for jpos in 0..<mValues.count {
             // Check row validity
-            let row: [UncertainValue<String, Int, Double>] =
-                mValues[jpos]
+            var rowValues = mValues[jpos]
             var isRun: Bool = true
 
             /* Remove types checking for allowing RDBMS Types
@@ -429,10 +425,9 @@ class ImportFromJson {
                                            "tableName": tableName]
                 let stmt: String = try ImportFromJson
                     .createRowStatement(mDB: mDB, data: data,
-                                        row: row,
+                                        row: rowValues,
                                         jsonNamesTypes: jsonNamesTypes)
-                var rowValues = UtilsJson.getValuesFromRow(
-                    rowValues: row)
+
                 isRun = try UtilsJson.checkUpdate(mDB: mDB, stmt: stmt,
                                                   values: rowValues,
                                                   tableName: tableName,
@@ -443,8 +438,9 @@ class ImportFromJson {
                     if stmt.prefix(6) == "DELETE" {
                         rowValues = []
                     }
-                    let lastId: Int64 = try UtilsSQLCipher.prepareSQL(
-                        mDB: mDB, sql: stmt, values: rowValues, fromJson: true)
+                    let resp = try UtilsSQLCipher.prepareSQL(
+                        mDB: mDB, sql: stmt, values: rowValues, fromJson: true, returnMode: "no")
+                    lastId = resp.0
                     if lastId < 0 {
                         throw ImportFromJsonError.createTableData(
                             message: "lastId < 0")
@@ -469,7 +465,7 @@ class ImportFromJson {
     class func createRowStatement(
         mDB: Database,
         data: [String: Any],
-        row: [UncertainValue<String, Int, Double>],
+        row: [Any],
         jsonNamesTypes: JsonNamesTypes) throws -> String {
         var stmt: String = ""
         var retisIdExists: Bool = false
@@ -487,19 +483,11 @@ class ImportFromJson {
                 message: message + " tableName")
         }
         do {
-            if let rwValue: Any = row[0].value {
-                retisIdExists = try UtilsJson.isIdExist(
-                    mDB: mDB, tableName: tableName,
-                    firstColumnName: jsonNamesTypes.names[0],
-                    key: rwValue)
-            } else {
-                var message: String = "createRowStatement: Table "
-                message.append("\(tableName) values row[0] does not ")
-                message.append("exist")
-                throw ImportFromJsonError.createRowStatement(
-                    message: message)
-            }
-
+            let rwValue = row[0]
+            retisIdExists = try UtilsJson.isIdExist(
+                mDB: mDB, tableName: tableName,
+                firstColumnName: jsonNamesTypes.names[0],
+                key: rwValue)
         } catch UtilsJsonError.isIdExists(let message) {
             throw ImportFromJsonError.createRowStatement(
                 message: message)
@@ -518,13 +506,13 @@ class ImportFromJson {
             let idxDelete: Int = jsonNamesTypes
                 .names.firstIndex(where: {$0 == "sql_deleted"}) ?? -1
             if idxDelete >= 0 {
-                if let delValue = row[idxDelete].value as? Int {
+                if let delValue = row[idxDelete] as? Int {
                     if delValue == 1 {
                         isUpdate = false
                         stmt = "DELETE FROM \(tableName) WHERE "
-                        if let rwValue = row[0].value as? String {
+                        if let rwValue = row[0] as? String {
                             stmt += "\(jsonNamesTypes.names[0]) = '\(rwValue)';"
-                        } else if let rwValue = row[0].value as? Int {
+                        } else if let rwValue = row[0] as? Int {
                             stmt += "\(jsonNamesTypes.names[0]) = \(rwValue);"
                         } else {
                             var msg: String = "importFromJson: Table "
@@ -548,9 +536,9 @@ class ImportFromJson {
                 }
 
                 stmt = "UPDATE \(tableName)  SET \(setString) WHERE "
-                if let rwValue = row[0].value as? String {
+                if let rwValue = row[0] as? String {
                     stmt += "\(jsonNamesTypes.names[0]) = '\(rwValue)';"
-                } else if let rwValue = row[0].value as? Int {
+                } else if let rwValue = row[0] as? Int {
                     stmt += "\(jsonNamesTypes.names[0]) = \(rwValue);"
                 } else {
                     var msg: String = "importFromJson: Table "
@@ -568,7 +556,7 @@ class ImportFromJson {
     // MARK: - ImportFromJson - createViews
 
     // swiftlint:disable function_body_length
-    class func createViews(mDB: Database, views: [JsonView]) throws -> Int {
+    class func createViews(mDB: Database, views: [ImportView]) throws -> Int {
         var changes: Int = 0
         var initChanges: Int = -1
         var isView: Bool = false
@@ -631,7 +619,7 @@ class ImportFromJson {
         return changes
 
     }
-    class func createView(mDB: Database, view: JsonView) throws {
+    class func createView(mDB: Database, view: ImportView) throws {
         let stmt = "CREATE VIEW IF NOT EXISTS \(view.name) AS \(view.value);"
         do {
             try UtilsSQLCipher.execute(mDB: mDB, sql: stmt)

package/ios/Plugin/ImportExportJson/JsonSQLite.swift

@@ -7,6 +7,13 @@
 //
 
 import Foundation
+
+public struct EncryptJson: Codable {
+    let expData: String
+    public func show() {
+        print("expData: \(expData) ")
+    }
+}
 public struct JsonSQLite: Codable {
     let database: String
     let version: Int

package/ios/Plugin/Utils/UtilsDownloadFromHTTP.swift

@@ -39,80 +39,80 @@ class UtilsDownloadFromHTTP {
                     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)
+            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)
                                 }
-                                // Delete the zip file
-                                try FileManager.default.removeItem(
-                                    at: fileCacheURL)
 
+                                // 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
                             }
-                            try UtilsFile.moveAllDBSQLite(
-                                fromURL: cacheURL,
-                                dirUrl: dbURL)
-                            completion(.success(true))
-                            return
-                        }
 
-                        // Handle potential file system errors
-                        catch let error {
-                            let msg = "\(error.localizedDescription)"
+                            // 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
                         }
-                    default:
-                        let msg = "Download: GET resquest not successful. http status code \(httpResponse.statusCode)"
+                    } else {
+                        let msg = "Download: not a valid http response"
                         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()
         }

package/ios/Plugin/Utils/UtilsDrop.swift

@@ -233,7 +233,8 @@ class UtilsDrop {
             retChanges = try self.dropViews(mDB: mDB)
             if changes >= 0 {
                 _ = try UtilsSQLCipher.prepareSQL(mDB: mDB, sql: "VACUUM;",
-                                                  values: [], fromJson: false)
+                                                  values: [], fromJson: false,
+                                                  returnMode: "no")
                 changes = UtilsSQLCipher.dbChanges(mDB: mDB.mDb) -
                     initChanges
             }

package/ios/Plugin/Utils/UtilsJson.swift

@@ -6,6 +6,8 @@
 //
 
 import Foundation
+import CryptoKit
+import CommonCrypto
 
 enum UtilsJsonError: Error {
     case tableNotExists(message: String)
@@ -20,7 +22,12 @@ enum UtilsJsonError: Error {
     case isLastModified(message: String)
     case isSqlDeleted(message: String)
     case checkUpdate(message: String)
-    case checkValues(message: String)}
+    case checkValues(message: String)
+    case encryptDictionaryToBase64(message: String)
+    case decryptBase64ToDictionary(message: String)
+}
+
+var mSalt = "jeep_capacitor_sqlite"
 
 // swiftlint:disable file_length
 // swiftlint:disable type_body_length
@@ -466,6 +473,121 @@ class UtilsJson {
         return isViews
     }
 
+    // MARK: encryptDictionaryToBase64
+
+    class func encryptDictionaryToBase64(_ dictionary: [String: Any], forAccount account: String) throws -> String {
+        // Encryption using Swift Crypto and Keychain-stored passphrase
+
+        let jsonData = try JSONSerialization.data(withJSONObject: dictionary)
+
+        let isPassPhrase = try UtilsSecret.isPassphrase(account: account)
+        if !isPassPhrase {
+            throw UtilsJsonError.encryptDictionaryToBase64(
+                message: "No passphrase stored")
+        }
+        let passphrase = UtilsSecret.getPassphrase(account: account)
+        // Generate a constant salt
+        let salt = Data(mSalt.utf8)
+
+        // Derive the encryption key using the passphrase and salt
+        guard let key = deriveSymmetricKeyFromPassphrase(passphrase, salt: salt) else {
+            throw UtilsJsonError.encryptDictionaryToBase64(
+                message: "No Encryption key returned")
+        }
+        let symKey = SymmetricKey(data: key)
+
+        // Use Swift Crypto to perform AES encryption with GCM mode
+        let sealedBox = try AES.GCM.seal(jsonData, using: symKey, nonce: AES.GCM.Nonce())
+
+        if let combined = sealedBox.combined {
+            // combined the salt and the encrypted data
+            var saltAndEncryptedData = salt
+            saltAndEncryptedData.append(combined)
+            // Convert to base64 string
+
+            let base64String = saltAndEncryptedData.base64EncodedString()
+            return base64String
+        } else {
+            throw UtilsJsonError.encryptDictionaryToBase64(
+                message: "Conversion to base64String failed")
+
+        }
+
+    }
+
+    // MARK: decrypt DictionaryToBase64
+
+    class func decryptBase64ToDictionary(_ base64String: String,
+                                         forAccount account: String)
+    throws -> [String: Any] {
+        guard let data = Data(base64Encoded: base64String) else {
+            throw UtilsJsonError.decryptBase64ToDictionary(
+                message: "Conversion from Base64 to Dictionary failed")
+
+        }
+        let isPassPhrase = try UtilsSecret.isPassphrase(account: account)
+        if !isPassPhrase {
+            throw UtilsJsonError.decryptBase64ToDictionary(
+                message: "No passphrase stored")
+        }
+        let passphrase = UtilsSecret.getPassphrase(account: account)
+        // Generate a constant salt
+        let salt = Data(mSalt.utf8)
+
+        // Derive the encryption key using the passphrase and salt
+        guard let key = deriveSymmetricKeyFromPassphrase(passphrase,
+                                                         salt: salt) else {
+            throw UtilsJsonError.encryptDictionaryToBase64(
+                message: "No Encryption key returned")
+        }
+        let symKey = SymmetricKey(data: key)
+
+        // Extract the encrypted data from the remaining bytes
+        let encryptedData = data.suffix(from: salt.count)
+
+        // Convert the base64 string to a sealed box
+        let sealedBox = try AES.GCM.SealedBox(combined: encryptedData)
+
+        // Decrypt the ciphertext using AES GCM open
+        let decryptedData = try AES.GCM.open(sealedBox, using: symKey)
+
+        // Convert decrypted data to dictionary
+        let dictionary = try JSONSerialization.jsonObject(
+            with: decryptedData) as? [String: Any] ?? [:]
+
+        return dictionary
+    }
+
+    // MARK: deriveSymmetricKeyFromPassphrase
+
+    class func deriveSymmetricKeyFromPassphrase(_ passphrase: String,
+                                                salt: Data)
+    -> Data? {
+
+        let passphraseData = Data(passphrase.utf8)
+        let keyLength = kCCKeySizeAES256
+        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
+                    CCKeyDerivationPBKDF(
+                        CCPBKDFAlgorithm(kCCPBKDF2),
+                        passphraseUnsafeRawBufferPointer.baseAddress,
+                        passphraseData.count,
+                        saltUnsafeRawBufferPointer.baseAddress,
+                        salt.count,
+                        CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA256),
+                        iterations,
+                        derivedKeyUnsafeMutableRawBufferPointer.baseAddress,
+                        derivedCount
+                    )
+                }
+            }
+        }
+        return derivationStatus == kCCSuccess ? derivedKeyData : nil
+    }
 }
 // swiftlint:enable type_body_length
 // swiftlint:enable file_length