@capacitor-community/sqlite 3.5.2-dev1 → 4.0.0-0

package/ios/Plugin/Database.swift

@@ -558,14 +558,20 @@ class Database {
         do {
             let date = Date()
             let syncTime: Int = Int(date.timeIntervalSince1970)
-            // Set the last exported date
-            try ExportToJson.setLastExportDate(mDB: self, sTime: syncTime)
+            let isExists: Bool = try UtilsJson.isTableExists(
+                mDB: self, tableName: "sync_table")
+            if isExists {
+                // Set the last exported date
+                try ExportToJson.setLastExportDate(mDB: self, sTime: syncTime)
+            }
             // Launch the export process
             let data: [String: Any] = [
                 "dbName": dbName, "encrypted": self.encrypted,
                 "expMode": expMode, "version": dbVersion]
             retObj = try ExportToJson
                 .createExportObject(mDB: self, data: data)
+        } catch UtilsJsonError.tableNotExists(let message) {
+            throw DatabaseError.exportToJson(message: message)
         } catch ExportToJsonError.setLastExportDate(let message) {
             throw DatabaseError.exportToJson(message: message)
         } catch ExportToJsonError.createExportObject(let message) {

package/ios/Plugin/Extensions/String.swift

@@ -8,12 +8,18 @@
 import Foundation
 
 extension String {
-    public func indicesOf(string: String) -> [Int] {
+    public func indicesOf(string: String, fromIdx: Int? = 0) -> [Int] {
         var indices = [Int]()
         var searchStartIndex = self.startIndex
+        if let fIdx = fromIdx {
+            if fIdx != 0 {
+                searchStartIndex = self.index(self.startIndex, offsetBy: fIdx)
+            }
+        }
+        
 
         while searchStartIndex < self.endIndex,
-              let range = self.range(of: string, range: searchStartIndex..<self.endIndex),
+              let range = self.range(of: string, options: .caseInsensitive, range: searchStartIndex..<self.endIndex),
               !range.isEmpty {
             let index = distance(from: self.startIndex, to: range.lowerBound)
             indices.append(index)

package/ios/Plugin/Utils/UtilsFile.swift

@@ -20,6 +20,7 @@ enum UtilsFileError: Error {
     case getDatabasesURLFailed
     case getApplicationPathFailed
     case getApplicationURLFailed
+    case getCacheURLFailed
     case getLibraryPathFailed
     case getLibraryURLFailed
     case getFileListFailed
@@ -148,6 +149,8 @@ class UtilsFile {
                 dbPathURL = try UtilsFile.getApplicationURL().absoluteURL
             } else if first[0] == "Library" {
                 dbPathURL = try UtilsFile.getLibraryURL().absoluteURL
+            }  else if first[0].caseInsensitiveCompare("cache") == .orderedSame {
+                dbPathURL = try UtilsFile.getCacheURL().absoluteURL
             } else if first[0] == "Documents" || first[0] == "default" {
                 dbPathURL = databaseURL
             } else {
@@ -238,6 +241,19 @@ class UtilsFile {
             throw UtilsFileError.getApplicationPathFailed
         }
     }
+    
+    // MARK: - getCacheURL
+
+    class func getCacheURL() throws -> URL {
+        if let path: String = NSSearchPathForDirectoriesInDomains(
+            .cachesDirectory, .userDomainMask, true
+        ).first {
+            return NSURL(fileURLWithPath: path) as URL
+        } else {
+            print("Error: getCacheURL did not find the cache folder")
+            throw UtilsFileError.getCacheURLFailed
+        }
+    }
 
     // MARK: - getLibraryURL
 

package/ios/Plugin/Utils/UtilsSQLCipher.swift

@@ -25,8 +25,9 @@ enum UtilsSQLCipherError: Error {
     case execute(message: String)
     case prepareSQL(message: String)
     case deleteSQL(message: String)
-    case findReferenciesAndUpdate(message: String)
-    case getReferencies(message: String)
+    case findReferencesAndUpdate(message: String)
+    case getReferences(message: String)
+    case getRefs(message: String)
     case querySQL(message: String)
     case fetchColumnInfo(message: String)
     case deleteDB(message: String)
@@ -503,17 +504,17 @@ class UtilsSQLCipher {
                     sqlStmt = "UPDATE \(tableName) SET sql_deleted = 1 "
                     sqlStmt += clauseStmt
                     // Find REFERENCIES if any and update the sql_deleted column
-                    try findReferenciesAndUpdate(mDB: mDB,
-                                                 tableName: tableName,
-                                                 whereStmt: clauseStmt,
-                                                 values: values)
+                    try findReferencesAndUpdate(mDB: mDB,
+                                                tableName: tableName,
+                                                whereStmt: clauseStmt,
+                                                values: values)
                 } else {
                     let msg: String = "deleteSQL cannot find a WHERE clause"
                     throw UtilsSQLCipherError.deleteSQL(message: msg)
                 }
             }
             return sqlStmt
-        } catch UtilsSQLCipherError.findReferenciesAndUpdate(let message) {
+        } catch UtilsSQLCipherError.findReferencesAndUpdate(let message) {
             throw UtilsSQLCipherError.deleteSQL(message: message)
         } catch UtilsJsonError.isLastModified(let message) {
             throw UtilsSQLCipherError.deleteSQL(message: message)
@@ -524,155 +525,301 @@ class UtilsSQLCipher {
 
     // MARK: - findReferencesAndUpdate
 
-    class func findReferenciesAndUpdate(mDB: Database, tableName: String,
-                                        whereStmt: String,
-                                        values: [Any]) throws {
+    // swiftlint:disable function_body_length
+    // swiftlint:disable cyclomatic_complexity
+    class func findReferencesAndUpdate(mDB: Database, tableName: String,
+                                       whereStmt: String,
+                                       values: [Any]) throws {
         do {
-            let referencies = try getReferencies(mDB: mDB,
-                                                 tableName: tableName)
-            if referencies.count <= 0 {
+            var references = try getReferences(mDB: mDB,
+                                               tableName: tableName)
+            if references.count <= 0 {
+                return
+            }
+            guard let tableNameWithRefs = references.last else {
                 return
             }
-            // Loop through referencies
-            for ref in referencies {
+            references.removeLast()
+            // Loop through references
+            for ref in references {
                 // get the tableName of the references
                 let refTable: String = getReferencesTableName(value: ref)
                 if refTable.count <= 0 {
                     continue
                 }
+                // get the with ref columnName
+                let withRefsNames: [String] = getWithRefsColumnName(value: ref)
+                if withRefsNames.count <= 0 {
+                    continue
+                }
                 // get the columnName
-                let colName: String = getReferencesColumnName(value: ref)
-                if colName.count <= 0 {
+                let colNames: [String] = getReferencesColumnName(value: ref)
+                if colNames.count <= 0 {
                     continue
                 }
                 // update the where clause
                 let uWhereStmt: String = updateWhere(whStmt: whereStmt,
-                                                     colName: colName)
+                                                     withRefs: withRefsNames,
+                                                     colNames: colNames)
 
                 if uWhereStmt.count <= 0 {
                     continue
                 }
+                var updTableName: String = tableNameWithRefs
+                var updColNames: [String] = colNames
+                if tableNameWithRefs == tableName {
+                    updTableName = refTable
+                    updColNames = withRefsNames
+                }
                 //update sql_deleted for this references
-                let stmt = "UPDATE \(refTable) SET sql_deleted = 1 " +
+                let stmt = "UPDATE \(updTableName) SET sql_deleted = 1 " +
                     uWhereStmt
+                var selValues: [Any] = []
+                if !values.isEmpty {
+                    var arrVal: [String] =  whereStmt.components(separatedBy: "?")
+                    if arrVal[arrVal.count - 1] == ";" {
+                        arrVal.removeLast()
+                    }
+                    for (jdx, val) in arrVal.enumerated() {
+                        for updVal in updColNames {
+                            let indices: [Int] = val.indicesOf(string: updVal)
+                            if indices.count > 0 {
+                                selValues.append(values[jdx])
+                            }
+                        }
+                    }
+                }
+
                 let lastId = try prepareSQL(mDB: mDB, sql: stmt,
-                                            values: values, fromJson: false)
+                                            values: selValues,
+                                            fromJson: false)
                 if lastId == -1 {
                     let msg = "UPDATE sql_deleted failed for references " +
                         "table: \(refTable) "
                     throw UtilsSQLCipherError
-                    .findReferenciesAndUpdate(message: msg)
+                    .findReferencesAndUpdate(message: msg)
                 }
             }
             return
         } catch UtilsSQLCipherError.prepareSQL(let message) {
             throw UtilsSQLCipherError
-            .findReferenciesAndUpdate(message: message)
+            .findReferencesAndUpdate(message: message)
         } catch UtilsSQLCipherError.querySQL(let message) {
             throw UtilsSQLCipherError
-            .findReferenciesAndUpdate(message: message)
+            .findReferencesAndUpdate(message: message)
         }
 
     }
+    // swiftlint:enable cyclomatic_complexity
+    // swiftlint:enable function_body_length
 
-    // MARK: - getReferencies
+    // MARK: - getReferences
 
-    class func getReferencies(mDB: Database, tableName: String)
-    throws -> [[String: Any]] {
-        // find the REFERENCIES
+    class func getReferences(mDB: Database, tableName: String)
+    throws -> [String] {
+        // find the REFERENCES
         var sqlStmt = "SELECT sql FROM sqlite_master "
-        sqlStmt += "WHERE sql LIKE('%REFERENCES%') AND "
+        sqlStmt += "WHERE sql LIKE('%FOREIGN KEY%') AND "
+        sqlStmt += "sql LIKE('%REFERENCES%') AND "
         sqlStmt += "sql LIKE('%\(tableName)%') AND sql LIKE('%ON DELETE%');"
         do {
-            var referencies: [[String: Any]] = try querySQL(mDB: mDB,
-                                                            sql: sqlStmt,
-                                                            values: [])
-            if referencies.count > 1 {
-                referencies.removeFirst()
+            var references: [[String: Any]] = try querySQL(mDB: mDB,
+                                                           sql: sqlStmt,
+                                                           values: [])
+            var retRefs: [String] = []
+            if references.count > 1 {
+                references.removeFirst()
+                if let refValue = references[0]["sql"] as? String {
+                    retRefs = try getRefs(str: refValue)
+                }
             }
-            return referencies
+            return retRefs
+        } catch UtilsSQLCipherError.getRefs(let message) {
+            throw UtilsSQLCipherError
+            .getReferences(message: message)
         } catch UtilsSQLCipherError.querySQL(let message) {
             throw UtilsSQLCipherError
-            .getReferencies(message: message)
+            .getReferences(message: message)
+        }
+    }
+    class func getRefs(str: String) throws -> [String] {
+        var retRefs: [String] = []
+        let indicesFK: [Int] = str.indicesOf(string: "FOREIGN KEY")
+        let indicesOD: [Int] = str.indicesOf(string: "ON DELETE")
+        if indicesFK.count > 0 && indicesOD.count > 0
+            && indicesFK.count != indicesOD.count {
+            let msg: String = "Indices of FOREIGN KEY and ON DELETE not equal"
+            throw UtilsSQLCipherError.getRefs(message: msg)
+
+        }
+        for (idx, iFK) in indicesFK.enumerated() {
+            let ref: String = String(str.stringRange(fromIdx: iFK + 11,
+                                                     toIdx: indicesOD[idx]))
+                .trimmingLeadingAndTrailingSpaces()
+            retRefs.append(ref)
         }
+
+        if let range: Range<String.Index> = str
+            .range(of: "CREATE TABLE", options: .caseInsensitive) {
+            let index: Int = str
+                .distance(from: str.startIndex, to: range.lowerBound)
+            let stmt = String(str.stringRange(fromIdx: index + 13,
+                                              toIdx: str.count))
+            if let oPar = stmt.firstIndex(of: "(") {
+                let idx: Int = stmt.distance(from: stmt.startIndex, to: oPar)
+                let tableName: String = String(stmt.stringRange(fromIdx: 0,
+                                                                toIdx: idx))
+                    .trimmingLeadingAndTrailingSpaces()
+                retRefs.append(tableName)
+            }
+        }
+
+        return retRefs
     }
 
     // MARK: - getReferencesTableName
 
-    class func getReferencesTableName(value: [String: Any]) -> String {
+    class func getReferencesTableName(value: String) -> String {
 
         var tableName: String = ""
-        if let refValue = value["sql"] as? String {
-
-            if let range: Range<String.Index> = refValue
-                .range(of: "CREATE TABLE", options: .caseInsensitive) {
-                let index: Int = refValue
-                    .distance(from: refValue.startIndex, to: range.lowerBound)
-                let stmt = String(refValue.stringRange(fromIdx: index + 13,
-                                                       toIdx: refValue.count))
-                if let oPar = stmt.firstIndex(of: "(") {
-                    let idx: Int = stmt.distance(from: stmt.startIndex, to: oPar)
-                    tableName = String(stmt.stringRange(fromIdx: 0, toIdx: idx))
-                        .trimmingLeadingAndTrailingSpaces()
-                }
+        if value.isEmpty {
+            return tableName
+        }
+        let indicesRef: [Int] = value.indicesOf(string: "REFERENCES")
+        if indicesRef.count > 0 {
+            let val: String = String(value.stringRange(
+                                        fromIdx: indicesRef[0] + 10,
+                                        toIdx: value.count))
+            if let oPar = val.firstIndex(of: "(") {
+                let idx: Int = val.distance(from: val.startIndex, to: oPar)
+                tableName = String(val.stringRange(fromIdx: 0,
+                                                   toIdx: idx))
+                    .trimmingLeadingAndTrailingSpaces()
             }
         }
         return tableName
     }
 
-    // MARK: - getReferencesColumnName
+    // MARK: - getWithRefColumnName
 
-    class func getReferencesColumnName(value: [String: Any]) -> String {
-
-        var colName: String = ""
-        if let refValue = value["sql"] as? String {
-
-            if let range: Range<String.Index> = refValue
-                .range(of: "FOREIGN KEY", options: .caseInsensitive) {
-                let index: Int = refValue
-                    .distance(from: refValue.startIndex, to: range.lowerBound)
-                let stmt = String(refValue.stringRange(fromIdx: index + 12,
-                                                       toIdx: refValue.count))
-                if let oPar = stmt.firstIndex(of: "(") {
-                    let idxOPar: Int = stmt.distance(from: stmt.startIndex,
-                                                     to: oPar) + 1
-                    if let cPar = stmt.firstIndex(of: ")") {
-                        let idxCPar: Int = stmt
-                            .distance(from: stmt.startIndex,
-                                      to: cPar)
-                        colName = String(stmt.stringRange(fromIdx: idxOPar,
-                                                          toIdx: idxCPar))
-                            .trimmingLeadingAndTrailingSpaces()
+    class func getWithRefsColumnName(value: String) -> [String] {
 
-                    }
+        var colNames: [String] = []
+        if value.isEmpty {
+            return colNames
+        }
+        let indicesRef: [Int] = value.indicesOf(string: "REFERENCES")
+        if indicesRef.count > 0 {
+            let val: String = String(value.stringRange(
+                                        fromIdx: 0,
+                                        toIdx: indicesRef[0] - 1))
+            if let oPar = val.firstIndex(of: "(") {
+                let idxOPar: Int = val.distance(from: val.startIndex, to: oPar)
+                if let cPar = val.firstIndex(of: ")") {
+                    let idxCPar: Int = val.distance(from: val.startIndex,
+                                                    to: cPar)
+
+                    let colStr: String = String(val
+                                                    .stringRange(fromIdx: idxOPar + 1,
+                                                                 toIdx: idxCPar))
+                        .trimmingLeadingAndTrailingSpaces()
+                    colNames = colStr.split(separator: ",").map(String.init)
                 }
             }
         }
+        return colNames
+    }
+    // MARK: - getReferencesColumnName
 
-        return colName
+    class func getReferencesColumnName(value: String) -> [String] {
+
+        var colNames: [String] = []
+        if value.isEmpty {
+            return colNames
+        }
+        let indicesRef: [Int] = value.indicesOf(string: "REFERENCES")
+        if indicesRef.count > 0 {
+            let val: String = String(value.stringRange(
+                                        fromIdx: indicesRef[0] + 10,
+                                        toIdx: value.count))
+            if let oPar = val.firstIndex(of: "(") {
+                let idxOPar: Int = val.distance(from: val.startIndex, to: oPar)
+                if let cPar = val.firstIndex(of: ")") {
+                    let idxCPar: Int = val.distance(from: val.startIndex,
+                                                    to: cPar)
+
+                    let colStr: String = String(val
+                                                    .stringRange(fromIdx: idxOPar + 1,
+                                                                 toIdx: idxCPar))
+                        .trimmingLeadingAndTrailingSpaces()
+                    colNames = colStr.split(separator: ",").map(String.init)
+
+                }
+            }
+        }
+        return colNames
     }
 
-    class func updateWhere(whStmt: String, colName: String) -> String {
+    // swiftlint:disable function_body_length
+    class func updateWhere(whStmt: String, withRefs: [String],
+                           colNames: [String]) -> String {
         var whereStmt = ""
-        if let range: Range<String.Index> = whStmt
-            .range(of: "WHERE", options: .caseInsensitive) {
-            let index: Int = whStmt
-                .distance(from: whStmt.startIndex, to: range.lowerBound)
-            let stmt = String(whStmt.stringRange(fromIdx: index + 6,
-                                                 toIdx: whStmt.count))
-            if let fEqual = stmt.firstIndex(of: "=") {
-                let idxfEqual: Int = stmt.distance(from: stmt.startIndex,
-                                                   to: fEqual)
-                let whereColName = String(stmt.stringRange(fromIdx: 0,
-                                                           toIdx: idxfEqual))
-                    .trimmingLeadingAndTrailingSpaces()
-                whereStmt = whStmt.replacingOccurrences(of: whereColName, with: colName)
+        if whStmt.count > 0 {
+            let indicesWhere: [Int] = whStmt.indicesOf(string: "WHERE")
+            if indicesWhere.count == 0 {
+                return whereStmt
+            }
+            var stmt: String = String(whStmt.stringRange(
+                                        fromIdx: indicesWhere[0] + 6,
+                                        toIdx: whStmt.count))
+            if withRefs.count == colNames.count {
+                for (idx, wRf) in withRefs.enumerated() {
+                    var colType: String = "withRefsNames"
+                    var idxs: [Int] = stmt.indicesOf(string: wRf)
+                    if idxs.count == 0 {
+                        idxs = stmt.indicesOf(string: colNames[idx])
+                        colType = "colNames"
+                    }
+                    if idxs.count > 0 {
+                        var valStr: String = ""
+                        let indicesEqual: [Int] = stmt
+                            .indicesOf(string: "=",
+                                       fromIdx: idxs[0])
+
+                        if indicesEqual.count > 0 {
+                            let indicesAnd: [Int] = stmt
+                                .indicesOf(string: "AND",
+                                           fromIdx: indicesEqual[0])
+                            if indicesAnd.count > 0 {
+                                valStr = String(stmt.stringRange(
+                                                    fromIdx: indicesEqual[0] + 1,
+                                                    toIdx: indicesAnd[0] - 1))
+                                stmt = String(stmt.stringRange(
+                                                fromIdx: indicesAnd[0] + 3,
+                                                toIdx: stmt.count))
+                            } else {
+                                valStr = String(stmt.stringRange(
+                                                    fromIdx: indicesEqual[0] + 1,
+                                                    toIdx: stmt.count))
+                            }
+                            if idx > 0 {
+                                whereStmt += " AND "
+                            }
+                            if colType == "withRefsNames" {
+                                whereStmt += colNames[idx] + " = " + valStr
+                            } else {
+                                whereStmt += withRefs[idx] + " = " + valStr
+                            }
+                        }
+                    }
 
+                }
+                whereStmt = "WHERE " + whereStmt
             }
         }
-
         return whereStmt
     }
+    // swiftlint:enable function_body_length
 
     // MARK: - querySQL
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor-community/sqlite",
-  "version": "3.5.2-dev1",
+  "version": "4.0.0-0",
   "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": "^3.5.1",
-    "@capacitor/core": "^3.5.1",
+    "@capacitor/android": "^4.0.0",
+    "@capacitor/core": "^4.0.0",
     "@capacitor/docgen": "^0.0.17",
-    "@capacitor/ios": "^3.5.1",
+    "@capacitor/ios": "^4.0.0",
     "@ionic/eslint-config": "^0.3.0",
     "@ionic/prettier-config": "^1.0.1",
     "@ionic/swiftlint-config": "^1.1.2",
@@ -66,15 +66,15 @@
     "@rollup/plugin-node-resolve": "^13.0.4",
     "electron": "^15.5.5",
     "eslint": "^7.11.0",
-    "prettier": "~2.2.0",
-    "prettier-plugin-java": "~1.0.0",
+    "prettier": "~2.3.0",
+    "prettier-plugin-java": "~1.0.2",
     "rimraf": "^3.0.2",
     "rollup": "^2.32.0",
     "swiftlint": "^1.0.1",
-    "typescript": "~4.0.5"
+    "typescript": "~4.1.5"
   },
   "peerDependencies": {
-    "@capacitor/core": "^3.0.0"
+    "@capacitor/core": "^4.0.0"
   },
   "prettier": "@ionic/prettier-config",
   "swiftlint": "@ionic/swiftlint-config",
@@ -93,6 +93,6 @@
     }
   },
   "dependencies": {
-    "jeep-sqlite": "^1.5.4-dev1"
+    "jeep-sqlite": "^1.5.4"
   }
 }