@capacitor-community/sqlite 5.0.7-2 → 5.0.7

package/ios/Plugin/CapacitorSQLite.swift

@@ -443,6 +443,125 @@ enum CapacitorSQLiteError: Error {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
     }
+    
+    // MARK: - BeginTransaction
+
+    @objc public func beginTransaction(_ dbName: String) throws -> [String: Any] {
+        if isInit {
+            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+            let connName: String = "RW_\(mDbName)"
+            guard let mDb: Database = dbDict[connName] else {
+                let msg = "Connection to \(mDbName) not available"
+                throw CapacitorSQLiteError.failed(message: msg)
+            }
+            if !mDb.isNCDB() && mDb.isDBOpen() {
+                do {
+                    let res = try mDb.beginTransaction()
+                    return ["changes": res]
+                } catch DatabaseError.beginTransaction(let message) {
+                    throw CapacitorSQLiteError.failed(message: message)
+                } catch let error {
+                    let msg: String = "\(error)"
+                    throw CapacitorSQLiteError.failed(message: msg)
+                }
+            } else {
+                let msg = "Database \(mDbName) not opened or in read-only"
+                throw CapacitorSQLiteError.failed(message: msg)
+            }
+        } else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+    }
+    
+    // MARK: - CommitTransaction
+
+    @objc public func commitTransaction(_ dbName: String) throws -> [String: Any] {
+        if isInit {
+            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+            let connName: String = "RW_\(mDbName)"
+            guard let mDb: Database = dbDict[connName] else {
+                let msg = "Connection to \(mDbName) not available"
+                throw CapacitorSQLiteError.failed(message: msg)
+            }
+            if !mDb.isNCDB() && mDb.isDBOpen() {
+                do {
+                    let res = try mDb.commitTransaction()
+                    return ["changes": res]
+                } catch DatabaseError.commitTransaction(let message) {
+                    throw CapacitorSQLiteError.failed(message: message)
+                } catch let error {
+                    let msg: String = "\(error)"
+                    throw CapacitorSQLiteError.failed(message: msg)
+                }
+            } else {
+                let msg = "Database \(mDbName) not opened or in read-only"
+                throw CapacitorSQLiteError.failed(message: msg)
+            }
+        } else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+    }
+    
+    // MARK: - RollbackTransaction
+
+    @objc public func rollbackTransaction(_ dbName: String)
+                                                throws -> [String: Any] {
+        if isInit {
+            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+            let connName: String = "RW_\(mDbName)"
+            guard let mDb: Database = dbDict[connName] else {
+                let msg = "Connection to \(mDbName) not available"
+                throw CapacitorSQLiteError.failed(message: msg)
+            }
+            if !mDb.isNCDB() && mDb.isDBOpen() {
+                do {
+                    let res = try mDb.rollbackTransaction()
+                    return ["changes": res]
+                } catch DatabaseError.rollbackTransaction(let message) {
+                    throw CapacitorSQLiteError.failed(message: message)
+                } catch let error {
+                    let msg: String = "\(error)"
+                    throw CapacitorSQLiteError.failed(message: msg)
+                }
+            } else {
+                let msg = "Database \(mDbName) not opened or in read-only"
+                throw CapacitorSQLiteError.failed(message: msg)
+            }
+        } else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+    }
+
+    // MARK: - IsTransactionActive
+
+    @objc public func isTransactionActive(_ dbName: String) throws -> NSNumber {
+        if isInit {
+            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+            let connName: String = "RW_\(mDbName)"
+            guard let mDb: Database = dbDict[connName] else {
+                let msg = "Connection to \(mDbName) not available"
+                throw CapacitorSQLiteError.failed(message: msg)
+            }
+            if !mDb.isNCDB() && mDb.isDBOpen() {
+
+                do {
+                    let isAvail = try mDb.isAvailTrans()
+                    if isAvail {
+                        return 1
+                    } else {
+                        return 0
+                    }
+                } catch DatabaseError.isAvailTrans(let message) {
+                    throw CapacitorSQLiteError.failed(message: message)
+                }
+            } else {
+                let msg = "Database \(mDbName) not opened or in read-only"
+                throw CapacitorSQLiteError.failed(message: msg)
+            }
+        } else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+    }
 
     // MARK: - getUrl
 

package/ios/Plugin/CapacitorSQLitePlugin.m

@@ -49,4 +49,8 @@ CAP_PLUGIN(CapacitorSQLitePlugin, "CapacitorSQLite",
            CAP_PLUGIN_METHOD(isInConfigEncryption, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(isInConfigBiometricAuth, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(isDatabaseEncrypted, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(beginTransaction, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(commitTransaction, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(rollbackTransaction, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(isTransactionActive, CAPPluginReturnPromise);
 )

package/ios/Plugin/CapacitorSQLitePlugin.swift

@@ -322,6 +322,134 @@ public class CapacitorSQLitePlugin: CAPPlugin {
         }
     }
 
+    // MARK: - BeginTransaction
+
+    @objc func beginTransaction(_ call: CAPPluginCall) {
+        guard let dbName = call.options["database"] as? String else {
+            retHandler.rChanges(
+                call: call, ret: ["changes": -1],
+                message: "BeginTransaction: Must provide a database name")
+            return
+        }
+        do {
+            if let ret = try implementation?.beginTransaction(dbName) {
+                retHandler.rChanges(call: call, ret: ret)
+                return
+            } else {
+                retHandler.rChanges(
+                    call: call, ret: ["changes": -1],
+                    message: "BeginTransaction: Does not return a valid execute")
+                return
+            }
+        } catch CapacitorSQLiteError.failed(let message) {
+            let msg = "BeginTransaction: \(message)"
+            retHandler.rChanges(
+                call: call, ret: ["changes": -1],
+                message: msg)
+            return
+        } catch let error {
+            retHandler.rChanges(
+                call: call, ret: ["changes": -1],
+                message: "BeginTransaction: \(error)")
+            return
+        }
+    }
+
+    // MARK: - CommitTransaction
+
+    @objc func commitTransaction(_ call: CAPPluginCall) {
+        guard let dbName = call.options["database"] as? String else {
+            retHandler.rChanges(
+                call: call, ret: ["changes": -1],
+                message: "CommitTransaction: Must provide a database name")
+            return
+        }
+        do {
+            if let ret = try implementation?.commitTransaction(dbName) {
+                retHandler.rChanges(call: call, ret: ret)
+                return
+            } else {
+                retHandler.rChanges(
+                    call: call, ret: ["changes": -1],
+                    message: "CommitTransaction: Does not return a valid execute")
+                return
+            }
+        } catch CapacitorSQLiteError.failed(let message) {
+            let msg = "CommitTransaction: \(message)"
+            retHandler.rChanges(
+                call: call, ret: ["changes": -1],
+                message: msg)
+            return
+        } catch let error {
+            retHandler.rChanges(
+                call: call, ret: ["changes": -1],
+                message: "CommitTransaction: \(error)")
+            return
+        }
+    }
+
+    // MARK: - RollbackTransaction
+
+    @objc func rollbackTransaction(_ call: CAPPluginCall) {
+        guard let dbName = call.options["database"] as? String else {
+            retHandler.rChanges(
+                call: call, ret: ["changes": -1],
+                message: "RollbackTransaction: Must provide a database name")
+            return
+        }
+        do {
+            if let ret = try implementation?.rollbackTransaction(dbName) {
+                retHandler.rChanges(call: call, ret: ret)
+                return
+            } else {
+                retHandler.rChanges(
+                    call: call, ret: ["changes": -1],
+                    message: "RollbackTransaction: Does not return a valid execute")
+                return
+            }
+        } catch CapacitorSQLiteError.failed(let message) {
+            let msg = "RollbackTransaction: \(message)"
+            retHandler.rChanges(
+                call: call, ret: ["changes": -1],
+                message: msg)
+            return
+        } catch let error {
+            retHandler.rChanges(
+                call: call, ret: ["changes": -1],
+                message: "RollbackTransaction: \(error)")
+            return
+        }
+    }
+
+    // MARK: - IsTransactionActive
+
+    @objc func isTransactionActive(_ call: CAPPluginCall) {
+        guard let dbName = call.options["database"] as? String else {
+            retHandler.rResult(
+                call: call,
+                message: "IsTransactionActive: Must provide a database name")
+            return
+        }
+        do {
+            let res = try implementation?.isTransactionActive(dbName)
+            var bRes: Bool = false
+            if res == 1 {
+                bRes = true
+            }
+            retHandler.rResult(call: call, ret: bRes)
+            return
+        } catch CapacitorSQLiteError.failed(let message) {
+            let msg = "IsTransactionActive: \(message)"
+            retHandler.rResult(call: call, message: msg)
+            return
+        } catch let error {
+            retHandler.rResult(
+                call: call,
+                message: "IsTransactionActive: \(error)")
+            return
+        }
+    }
+
     // MARK: - GetUrl
 
     @objc func getUrl(_ call: CAPPluginCall) {

package/ios/Plugin/Database.swift

@@ -25,6 +25,10 @@ enum DatabaseError: Error {
     case importFromJson(message: String)
     case getTableNames(message: String)
     case deleteExportedRows(message: String)
+    case isAvailTrans(message: String)
+    case beginTransaction(message: String)
+    case commitTransaction(message: String)
+    case rollbackTransaction(message: String)
 }
 // swiftlint:disable file_length
 // swiftlint:disable type_body_length
@@ -44,6 +48,7 @@ class Database {
     let uUpg: UtilsUpgrade = UtilsUpgrade()
     var readOnly: Bool = false
     var ncDB: Bool = false
+    var isAvailableTransaction = false
 
     // MARK: - Init
     init(databaseLocation: String, databaseName: String,
@@ -221,6 +226,77 @@ class Database {
         return
     }
 
+    // MARK: - IsAvailTrans
+
+    func isAvailTrans() throws -> Bool {
+        if isOpen {
+            return isAvailableTransaction
+        } else {
+            let msg: String = "Failed in isAvailTrans database not opened"
+            throw DatabaseError.isAvailTrans(message: msg)
+        }
+    }
+    
+    // MARK: - SetIsTransActive
+
+    func setIsTransActive(newValue: Bool ) {
+        isAvailableTransaction = newValue
+    }
+
+    // MARK: - BeginTransaction
+
+    func beginTransaction() throws -> Int {
+        if isOpen {
+            do {
+                try UtilsSQLCipher.beginTransaction(mDB: self)
+                setIsTransActive(newValue: true)
+                return 0
+            } catch UtilsSQLCipherError.beginTransaction(let message) {
+                let msg: String = "Failed in beginTransaction \(message)"
+                throw DatabaseError.beginTransaction(message: msg)
+            }
+        } else {
+            let msg: String = "Failed in beginTransaction database not opened"
+            throw DatabaseError.beginTransaction(message: msg)
+        }
+    }
+
+    // MARK: - CommitTransaction
+
+    func commitTransaction() throws -> Int {
+        if isOpen {
+            do {
+                try UtilsSQLCipher.commitTransaction(mDB: self)
+                setIsTransActive(newValue: false)
+                return 0
+            } catch UtilsSQLCipherError.commitTransaction(let message) {
+                let msg: String = "Failed in commitTransaction \(message)"
+                throw DatabaseError.commitTransaction(message: msg)
+            }
+        } else {
+            let msg: String = "Failed in commitTransaction database not opened"
+            throw DatabaseError.commitTransaction(message: msg)
+        }
+    }
+
+    // MARK: - RollbackTransaction
+
+    func rollbackTransaction() throws -> Int {
+        if isOpen {
+            do {
+                try UtilsSQLCipher.rollbackTransaction(mDB: self)
+                setIsTransActive(newValue: false)
+                return 0
+            } catch UtilsSQLCipherError.rollbackTransaction(let message) {
+                let msg: String = "Failed in rollbackTransaction \(message)"
+                throw DatabaseError.rollbackTransaction(message: msg)
+            }
+        } else {
+            let msg: String = "Failed in rollbackTransaction database not opened"
+            throw DatabaseError.rollbackTransaction(message: msg)
+        }
+    }
+
     // MARK: - GetVersion
 
     func getVersion () throws -> Int {

package/ios/Plugin/ImportExportJson/ImportFromJson.swift

@@ -82,6 +82,7 @@ class ImportFromJson {
         do {
             // Start a transaction
             try UtilsSQLCipher.beginTransaction(mDB: mDB)
+            mDB.setIsTransActive(newValue: true)
         } catch UtilsSQLCipherError.beginTransaction(let message) {
             throw ImportFromJsonError.createSchema(message: message)
         }
@@ -103,7 +104,8 @@ class ImportFromJson {
                         // Rollback the transaction
                         try UtilsSQLCipher
                             .rollbackTransaction(mDB: mDB)
-                    } catch UtilsSQLCipherError
+                        mDB.setIsTransActive(newValue: false)
+                   } catch UtilsSQLCipherError
                                 .rollbackTransaction(let message) {
                         throw ImportFromJsonError
                         .createSchema(message: message)
@@ -111,6 +113,7 @@ class ImportFromJson {
                 }
                 // Commit the transaction
                 try UtilsSQLCipher.commitTransaction(mDB: mDB)
+                mDB.setIsTransActive(newValue: false)
 
             } catch UtilsSQLCipherError.execute(let message) {
                 var msg = message
@@ -118,6 +121,7 @@ class ImportFromJson {
                     // Rollback the transaction
                     try UtilsSQLCipher
                         .rollbackTransaction(mDB: mDB)
+                    mDB.setIsTransActive(newValue: false)
                     throw ImportFromJsonError
                     .createSchema(message: message)
                 } catch UtilsSQLCipherError
@@ -135,6 +139,7 @@ class ImportFromJson {
                 changes = 0
                 // Commit the transaction
                 try UtilsSQLCipher.commitTransaction(mDB: mDB)
+                mDB.setIsTransActive(newValue: false)
             }
         }
         return changes
@@ -314,6 +319,7 @@ class ImportFromJson {
             initChanges = UtilsSQLCipher.dbChanges(mDB: mDB.mDb)
             // Start a transaction
             try UtilsSQLCipher.beginTransaction(mDB: mDB)
+            mDB.setIsTransActive(newValue: true)
         } catch UtilsSQLCipherError.beginTransaction(let message) {
             throw ImportFromJsonError.createDatabaseData(message: message)
         }
@@ -341,6 +347,7 @@ class ImportFromJson {
                             // Rollback the transaction
                             try UtilsSQLCipher
                                 .rollbackTransaction(mDB: mDB)
+                            mDB.setIsTransActive(newValue: false)
                             throw ImportFromJsonError
                             .createDatabaseData(message: message)
                         } catch UtilsSQLCipherError
@@ -359,6 +366,7 @@ class ImportFromJson {
         do {
             // Commit the transaction
             try UtilsSQLCipher.commitTransaction(mDB: mDB)
+            mDB.setIsTransActive(newValue: false)
             changes = UtilsSQLCipher.dbChanges(mDB: mDB.mDb) -
                 initChanges
             let msg = "Tables data creation completed changes: \(changes)"
@@ -566,6 +574,7 @@ class ImportFromJson {
             initChanges = UtilsSQLCipher.dbChanges(mDB: mDB.mDb)
             // Start a transaction
             try UtilsSQLCipher.beginTransaction(mDB: mDB)
+            mDB.setIsTransActive(newValue: true)
         } catch UtilsSQLCipherError.beginTransaction(let message) {
             throw ImportFromJsonError.createDatabaseData(message: message)
         }
@@ -590,6 +599,7 @@ class ImportFromJson {
             do {
                 // Commit the transaction
                 try UtilsSQLCipher.commitTransaction(mDB: mDB)
+                mDB.setIsTransActive(newValue: false)
                 changes = UtilsSQLCipher
                     .dbChanges(mDB: mDB.mDb) - initChanges
             } catch UtilsSQLCipherError.commitTransaction(
@@ -604,7 +614,8 @@ class ImportFromJson {
                     // Rollback the transaction
                     try UtilsSQLCipher
                         .rollbackTransaction(mDB: mDB)
-                    throw ImportFromJsonError
+                    mDB.setIsTransActive(newValue: false)
+                   throw ImportFromJsonError
                     .createViews(message: msg)
                 } catch UtilsSQLCipherError
                             .rollbackTransaction(let message) {