@capgo/capacitor-data-storage-sqlite 6.0.0

package/ios/Plugin/Utils/Blob.swift

@@ -0,0 +1,41 @@
+//
+//  Blob.swift
+//  Plugin
+//
+//  Created by  Quéau Jean Pierre on 08/04/2021.
+//  Copyright © 2021 Max Lynch. All rights reserved.
+//
+
+import Foundation
+
+public struct Blob {
+
+    public let bytes: [UInt8]
+
+    public init(bytes: [UInt8]) {
+        self.bytes = bytes
+    }
+
+    public init(bytes: UnsafeRawPointer, length: Int) {
+        let i8bufptr = UnsafeBufferPointer(start: bytes.assumingMemoryBound(to: UInt8.self), count: length)
+        self.init(bytes: [UInt8](i8bufptr))
+    }
+
+    public func toHex() -> String {
+        return bytes.map {($0 < 16 ? "0" : "") + String($0, radix: 16, uppercase: false)
+        }.joined(separator: "")
+    }
+
+}
+
+extension Blob: CustomStringConvertible {
+
+    public var description: String {
+        return "x'\(toHex())'"
+    }
+
+}
+
+public func == (lhs: Blob, rhs: Blob) -> Bool {
+    return lhs.bytes == rhs.bytes
+}

package/ios/Plugin/Utils/UtilsBinding.swift

@@ -0,0 +1,73 @@
+//
+//  UtilsBinding.swift
+//  Plugin
+//
+//  Created by  Quéau Jean Pierre on 12/04/2021.
+//  Copyright © 2021 Max Lynch. All rights reserved.
+//
+
+import Foundation
+import SQLCipher
+
+let SQLITETRANSIENT = unsafeBitCast(-1, to:
+                                        sqlite3_destructor_type.self)
+
+class UtilsBinding {
+    class func bindValues( handle: OpaquePointer?, values: [String])
+    -> String {
+        var message: String = ""
+        var idx: Int = 1
+        for value in values {
+            do {
+                if let selStmt = handle {
+                    try UtilsBinding.bind(handle: selStmt,
+                                          value: value, idx: idx)
+                    idx += 1
+                } else {
+                    message = "Error: querySQL bind failed "
+                }
+            } catch let error as NSError {
+                message = "Error: querySQL bind failed "
+                message.append("\(error.localizedDescription)")
+            }
+            if message.count > 0 { break }
+        }
+        return message
+    }
+    class func bind( handle: OpaquePointer?, value: Any?, idx: Int)
+    throws {
+        if value == nil {
+            sqlite3_bind_null(handle, Int32(idx))
+        } else if (value as? NSNull) != nil {
+            sqlite3_bind_null(handle, Int32(idx))
+        } else if let value = value as? Double {
+            sqlite3_bind_double(handle, Int32(idx), value)
+        } else if let value = value as? Int64 {
+            sqlite3_bind_int64(handle, Int32(idx), value)
+        } else if let value = value as? String {
+            if value.contains("base64") {
+                // case Base64 string as Blob
+                //                sqlite3_bind_blob(handle, Int32(idx), [value],
+                //                               Int32(value.count), SQLITETRANSIENT)
+                sqlite3_bind_text(handle, Int32(idx), value, -1,
+                                  SQLITETRANSIENT)
+
+            } else if value.uppercased() == "NULL" {
+                // case NULL
+                sqlite3_bind_null(handle, Int32(idx))
+            } else {
+                sqlite3_bind_text(handle, Int32(idx), value, -1,
+                                  SQLITETRANSIENT)
+            }
+        } else if let value = value as? Int {
+            sqlite3_bind_int64(handle, Int32(idx), Int64(value))
+        } else if let value = value as? Bool {
+            var bInt: Int32 = Int32(0)
+            if value {bInt = Int32(1)}
+            sqlite3_bind_int(handle, Int32(idx), Int32(bInt))
+        } else {
+            throw UtilsSQLCipherError.bindFailed
+        }
+
+    }
+}

package/ios/Plugin/Utils/UtilsEncryption.swift

@@ -0,0 +1,79 @@
+//
+//  UtilsEncryption.swift
+//  Plugin
+//
+//  Created by  Quéau Jean Pierre on 12/04/2021.
+//  Copyright © 2021 Max Lynch. All rights reserved.
+//
+
+import Foundation
+import SQLCipher
+
+enum UtilsEncryptionError: Error {
+    case encryptionFailed(message: String)
+}
+class UtilsEncryption {
+
+    // MARK: - EncryptDatabase
+    // swiftlint:disable function_body_length
+    class func encryptDatabase(filePath: String, password: String)
+    throws -> Bool {
+        var ret: Bool = false
+        var oDB: OpaquePointer?
+        do {
+            if UtilsFile.isFileExist(filePath: filePath) {
+                do {
+                    let tempPath: String = try UtilsFile.getFilePath(
+                        fileName: "temp.db")
+                    try UtilsFile.renameFile(filePath: filePath,
+                                             toFilePath: tempPath)
+                    oDB = try UtilsSQLCipher
+                        .openOrCreateDatabase(filename: tempPath,
+                                              password: "",
+                                              readonly: false)
+                    try _ = UtilsSQLCipher
+                        .openOrCreateDatabase(filename: filePath,
+                                              password: password,
+                                              readonly: false)
+
+                    var stmt: String = "ATTACH DATABASE '\(filePath)' "
+                    stmt.append("AS encrypted KEY '\(password)';")
+                    stmt.append("SELECT sqlcipher_export('encrypted');")
+                    stmt.append("DETACH DATABASE encrypted;")
+                    if sqlite3_exec(oDB, stmt, nil, nil, nil) ==
+                        SQLITE_OK {
+                        try UtilsFile.deleteFile(
+                            fileName: "temp.db")
+                        ret = true
+                    }
+                    // close the db
+                    try UtilsSQLCipher.close(oDB: oDB)
+
+                } catch UtilsFileError.getFilePathFailed {
+                    throw UtilsEncryptionError
+                    .encryptionFailed(message: "file path failed")
+                } catch UtilsFileError.renameFileFailed {
+                    throw UtilsEncryptionError
+                    .encryptionFailed(message: "file rename failed")
+                } catch UtilsSQLCipherError.openOrCreateDatabase(_) {
+                    throw UtilsEncryptionError
+                    .encryptionFailed(message: "open failed")
+                } catch UtilsSQLCipherError.close(_) {
+                    throw UtilsEncryptionError
+                    .encryptionFailed(message: "close failed")
+                } catch let error {
+                    print("Error: \(error)")
+                    throw UtilsEncryptionError
+                    .encryptionFailed(message: "Error: \(error)")
+                }
+            }
+        } catch let error {
+            print("Error: \(error)")
+            throw UtilsEncryptionError
+            .encryptionFailed(message: "Error: \(error)")
+        }
+        return ret
+    }
+
+}
+// swiftlint:enable function_body_length

package/ios/Plugin/Utils/UtilsFile.swift

@@ -0,0 +1,244 @@
+//
+//  UtilsFile.swift
+//  Plugin
+//
+//  Created by  Quéau Jean Pierre on 12/04/2021.
+//  Copyright © 2021 Max Lynch. All rights reserved.
+//
+
+import Foundation
+enum UtilsFileError: Error {
+    case getFilePathFailed
+    case copyFileFailed
+    case renameFileFailed
+    case deleteFileFailed
+    case getAssetsDatabasesPathFailed
+    case getDatabasesPathFailed
+    case getDatabasesURLFailed
+    case getApplicationPathFailed
+    case getApplicationURLFailed
+    case getLibraryPathFailed
+    case getLibraryURLFailed
+    case getFileListFailed
+    case copyFromAssetToDatabaseFailed
+    case copyFromNamesFailed
+}
+
+class UtilsFile {
+
+    // MARK: - IsFileExist
+
+    class func isDirExist(dirPath: String) -> Bool {
+        var isDir: ObjCBool = true
+        let fileManager = FileManager.default
+        let exists = fileManager.fileExists(atPath: dirPath, isDirectory: &isDir)
+        return exists && isDir.boolValue
+    }
+
+    // MARK: - IsFileExist
+
+    class func isFileExist(filePath: String) -> Bool {
+        var ret: Bool = false
+        let fileManager = FileManager.default
+        if fileManager.fileExists(atPath: filePath) {
+            ret = true
+        }
+        return ret
+    }
+    class func isFileExist(fileName: String) -> Bool {
+        var ret: Bool = false
+        do {
+            let filePath: String =
+                try UtilsFile.getFilePath(
+                    fileName: fileName)
+            ret = UtilsFile.isFileExist(filePath: filePath)
+            return ret
+        } catch UtilsFileError.getFilePathFailed {
+            return false
+        } catch _ {
+            return false
+        }
+    }
+
+    // MARK: - GetFilePath
+
+    class func getFilePath(fileName: String) throws -> String {
+        do {
+            let url = try getDatabasesUrl()
+            return url.appendingPathComponent("\(fileName)").path
+        } catch UtilsFileError.getDatabasesURLFailed {
+            print("Error: getDatabasesUrl Failed")
+            throw UtilsFileError.getFilePathFailed
+        }
+    }
+
+    // MARK: - getDatabasesUrl
+
+    class func getDatabasesUrl() throws -> URL {
+        if let path: String = NSSearchPathForDirectoriesInDomains(
+            .documentDirectory, .userDomainMask, true
+        ).first {
+            return NSURL(fileURLWithPath: path) as URL
+        } else {
+            print("Error: getDatabasesURL did not find the document folder")
+            throw UtilsFileError.getDatabasesURLFailed
+        }
+    }
+
+    // MARK: - getDatabasesPath
+    class func getDatabasesPath() throws -> String {
+        if let path: String = NSSearchPathForDirectoriesInDomains(
+            .documentDirectory, .userDomainMask, true
+        ).first {
+            return path
+        } else {
+            print("Error: getDatabasesPath did not find the document folder")
+            throw UtilsFileError.getDatabasesPathFailed
+        }
+    }
+
+    // MARK: - GetFileList
+
+    class func getFileList(path: String) throws -> [String] {
+        do {
+            var dbs: [String] = []
+            let filenames = try FileManager.default
+                .contentsOfDirectory(atPath: path)
+            let ext: String = ".db"
+            for file in filenames {
+                if file.hasSuffix(ext) {
+                    dbs.append(file)
+                }
+            }
+            return dbs
+        } catch let error {
+            print("Error: \(error)")
+            throw UtilsFileError.getFileListFailed
+        }
+    }
+
+    // MARK: - CopyFromNames
+
+    class func copyFromNames(dbPathURL: URL, fromFile: String, databaseURL: URL,
+                             toFile: String) throws {
+        do {
+            let uFrom: URL = dbPathURL.appendingPathComponent(fromFile)
+            let uTo: URL = databaseURL.appendingPathComponent(toFile)
+            let pFrom: String = uFrom.path
+            let pTo: String = uTo.path
+            let bRet: Bool = try copyFile(pathName: pFrom, toPathName: pTo)
+            if bRet {
+                return
+            } else {
+                print("Error: FromNames return false")
+                throw UtilsFileError.copyFromNamesFailed
+            }
+        } catch UtilsFileError.copyFileFailed {
+            print("Error: copyFile Failed")
+            throw UtilsFileError.copyFromNamesFailed
+        }
+
+    }
+
+    // MARK: - CopyFile
+
+    class func copyFile(pathName: String, toPathName: String) throws -> Bool {
+        if pathName.count > 0 && toPathName.count > 0 {
+            let isPath = isFileExist(filePath: pathName)
+            if isPath {
+                do {
+                    if isFileExist(filePath: toPathName) {
+                        _ = try deleteFile(filePath: toPathName)
+                    }
+                    let fileManager = FileManager.default
+                    try fileManager.copyItem(atPath: pathName,
+                                             toPath: toPathName)
+                    return true
+                } catch let error {
+                    print("Error: \(error)")
+                    throw UtilsFileError.copyFileFailed
+                }
+            } else {
+                print("Error: CopyFilePath Failed pathName does not exist")
+                throw UtilsFileError.copyFileFailed
+            }
+        } else {
+            print("Error: CopyFilePath Failed paths count = 0")
+            throw UtilsFileError.copyFileFailed
+        }
+    }
+
+    // MARK: - CopyFile
+
+    class func copyFile(fileName: String, toFileName: String)
+    throws -> Bool {
+        var ret: Bool = false
+        do {
+            let fromPath: String = try getFilePath(fileName: fileName)
+            let toPath: String = try getFilePath(fileName: toFileName)
+            ret = try copyFile(pathName: fromPath, toPathName: toPath)
+            return ret
+        } catch UtilsFileError.getFilePathFailed {
+            print("Error: getFilePath Failed")
+            throw UtilsFileError.copyFileFailed
+        } catch let error {
+            print("Error: \(error)")
+            throw UtilsFileError.copyFileFailed
+        }
+    }
+
+    // MARK: - DeleteFile
+
+    class func deleteFile(filePath: String) throws {
+        do {
+            if isFileExist(filePath: filePath) {
+                let fileManager = FileManager.default
+                do {
+                    try fileManager.removeItem(atPath: filePath)
+                } catch let error {
+                    print("Error: \(error)")
+                    throw UtilsFileError.deleteFileFailed
+                }
+            }
+            return
+        } catch let error {
+            print("Error: \(error)")
+            throw UtilsFileError.deleteFileFailed
+        }
+    }
+
+    // MARK: - DeleteFile
+
+    class func deleteFile(fileName: String) throws {
+        do {
+            let filePath: String = try getFilePath(fileName: fileName)
+            try deleteFile(filePath: filePath)
+            return
+        } catch let error {
+            print("Error: \(error)")
+            throw UtilsFileError.deleteFileFailed
+        }
+    }
+
+    // MARK: - RenameFile
+
+    class func renameFile (filePath: String, toFilePath: String)
+    throws {
+        let fileManager = FileManager.default
+        do {
+            if isFileExist(filePath: toFilePath) {
+                let fileName = URL(
+                    fileURLWithPath: toFilePath).lastPathComponent
+                try deleteFile(fileName: fileName)
+            }
+            try fileManager.moveItem(atPath: filePath,
+                                     toPath: toFilePath)
+        } catch UtilsFileError.deleteFileFailed {
+            print("Error: Failed in delete file")
+            throw UtilsFileError.renameFileFailed
+        } catch let error {
+            print("Error: \(error)")
+            throw UtilsFileError.renameFileFailed
+        }
+    }
+}