@capacitor-community/sqlite 5.7.1 → 5.7.3-1

package/ios/Plugin/Utils/UtilsSQLStatement.swift

@@ -11,6 +11,11 @@ enum UtilsSQLStatementError: Error {
     case addPrefixToWhereClause(message: String)
 }
 
+struct SQLStatementInfo {
+    let isReturning: Bool
+    let stmtString: String
+    let resultString: String
+}
 // swiftlint:disable file_length
 // swiftlint:disable type_body_length
 class UtilsSQLStatement {
@@ -69,13 +74,101 @@ class UtilsSQLStatement {
 
     class func addPrefixToWhereClause(_ whereClause: String,
                                       from: [String],
-                                      to: [String], prefix: String)
+                                      destination: [String], prefix: String)
+    throws -> String {
+        let columnValuePairs = getColumnValuePairs(from: from, destination: destination, whereClause: whereClause)
+
+        let modifiedPairs = try columnValuePairs.map({ pair in
+            return try modifyPair(pair,
+                                  from: from,
+                                  destination: destination,
+                                  prefix: prefix)
+        })
+
+        return modifiedPairs.joined(separator: " AND ")
+    }
+
+    // MARK: - getColumnValuePairs
+
+    class func getColumnValuePairs(from: [String],
+                                   destination: [String],
+                                   whereClause: String) -> [String] {
+        if whereClause.contains("AND") {
+            if #available(iOS 16.0, *) {
+                return whereClause.split(separator: "AND").map({ String($0) })
+            } else {
+                return whereClause.components(separatedBy: "AND")
+            }
+        } else {
+            return [whereClause]
+        }
+    }
+    class func modifyPair(_ pair: String, from: [String],
+                          destination: [String],prefix: String) throws -> String {
+        
+        let pattern = #"(\w+)\s*(=|IN|BETWEEN|LIKE)\s*(.+)"#
+
+        guard let range = pair.range(of: pattern, options: .regularExpression) else {
+            return pair
+        }
+
+        let match = String(pair[range])
+        let regex = try NSRegularExpression(pattern: pattern)
+        let matchRange = NSRange(match.startIndex..., in: match)
+
+        guard let matchResult = regex.firstMatch(in: match, range: matchRange) else {
+            let msg = "addPrefixToWhereClause: match result not found"
+            throw UtilsSQLStatementError.addPrefixToWhereClause(message: msg)
+        }
+
+        guard let columnRange = Range(matchResult.range(at: 1), in: match) else {
+            let msg = "addPrefixToWhereClause: columnRange failed"
+            throw UtilsSQLStatementError.addPrefixToWhereClause(message: msg)
+        }
+
+        guard let operatorRange = Range(matchResult.range(at: 2), in: match) else {
+            let msg = "addPrefixToWhereClause:  " +
+                "operatorRange failed "
+            throw UtilsSQLStatementError
+            .addPrefixToWhereClause(message: msg)
+        }
+        guard let valueRange = Range(matchResult.range(at: 3), in: match) else {
+            let msg = "addPrefixToWhereClause:  " +
+                "valueRange failed "
+            throw UtilsSQLStatementError
+            .addPrefixToWhereClause(message: msg)
+        }
+
+        let column = String(match[columnRange]).trimmingCharacters(in: .whitespacesAndNewlines)
+        let mOperator = String(match[operatorRange]).trimmingCharacters(in: .whitespacesAndNewlines)
+        let value = String(match[valueRange]).trimmingCharacters(in: .whitespacesAndNewlines)
+
+        var newColumn = column
+        if let index = UtilsSQLStatement
+            .findIndexOfStringInArray(column, destination), index != -1 {
+            guard let mNewColumn = UtilsSQLStatement
+                    .getStringAtIndex(from, index) else {
+                let msg = "addPrefixToWhereClause: index " +
+                    "mistmatch "
+                throw UtilsSQLStatementError
+                .addPrefixToWhereClause(message: msg)
+            }
+            newColumn = mNewColumn
+        }
+
+        let modifiedColumn = "\(prefix)\(newColumn)"
+        return "\(modifiedColumn) \(mOperator) \(value)"
+    }
+/*
+    class func addPrefixToWhereClause(_ whereClause: String,
+                                      from: [String],
+                                      destination: [String], prefix: String)
     throws -> String {
         var columnValuePairs: [String]
         if whereClause.contains("AND") {
             if #available(iOS 16.0, *) {
                 let subSequenceArray = whereClause.split(separator: "AND")
-                columnValuePairs = subSequenceArray.map { String($0) }
+                columnValuePairs = subSequenceArray.map({ String($0) })
             } else {
                 columnValuePairs = whereClause
                     .components(separatedBy: "AND")
@@ -83,7 +176,7 @@ class UtilsSQLStatement {
         } else {
             columnValuePairs = [whereClause]
         }
-        let modifiedPairs = try columnValuePairs.map { pair -> String in
+        let modifiedPairs = try columnValuePairs.map({ pair -> String in
             let pattern = #"(\w+)\s*(=|IN|BETWEEN|LIKE)\s*(.+)"#
 
             if let range = pair.range(of: pattern, options: .regularExpression) {
@@ -92,9 +185,25 @@ class UtilsSQLStatement {
                 let matchRange = NSRange(match.startIndex..., in: match)
 
                 if let matchResult = regex.firstMatch(in: match, range: matchRange) {
-                    let columnRange = Range(matchResult.range(at: 1), in: match)!
-                    let operatorRange = Range(matchResult.range(at: 2), in: match)!
-                    let valueRange = Range(matchResult.range(at: 3), in: match)!
+
+                    guard let columnRange = Range(matchResult.range(at: 1), in: match) else {
+                        let msg = "addPrefixToWhereClause:  " +
+                            "columnRange failed "
+                        throw UtilsSQLStatementError
+                        .addPrefixToWhereClause(message: msg)
+                    }
+                    guard let operatorRange = Range(matchResult.range(at: 2), in: match) else {
+                        let msg = "addPrefixToWhereClause:  " +
+                            "operatorRange failed "
+                        throw UtilsSQLStatementError
+                        .addPrefixToWhereClause(message: msg)
+                    }
+                    guard let valueRange = Range(matchResult.range(at: 3), in: match) else {
+                        let msg = "addPrefixToWhereClause:  " +
+                            "valueRange failed "
+                        throw UtilsSQLStatementError
+                        .addPrefixToWhereClause(message: msg)
+                    }
 
                     let column = String(match[columnRange]).trimmingCharacters(in: .whitespacesAndNewlines)
                     let mOperator = String(match[operatorRange]).trimmingCharacters(in: .whitespacesAndNewlines)
@@ -102,7 +211,7 @@ class UtilsSQLStatement {
 
                     var newColumn = column
                     if let index = UtilsSQLStatement
-                        .findIndexOfStringInArray(column, to), index != -1 {
+                        .findIndexOfStringInArray(column, destination), index != -1 {
                         guard let mNewColumn = UtilsSQLStatement
                                 .getStringAtIndex(from, index) else {
                             let msg = "addPrefixToWhereClause: index " +
@@ -118,11 +227,11 @@ class UtilsSQLStatement {
                 }
             }
             return pair
-        }
+        })
         return modifiedPairs.joined(separator: " AND ")
 
     }
-
+*/
     // MARK: - findIndexOfStringInArray
 
     class func findIndexOfStringInArray(_ target: String, _ array: [String]) -> Int? {
@@ -140,16 +249,18 @@ class UtilsSQLStatement {
     }
     // MARK: - extractForeignKeyInfo
 
-    // swiftlint:enable function_body_length
-    // swiftlint:enable type_body_length
+    // swiftlint:disable function_body_length
     class func extractForeignKeyInfo(from sqlStatement: String)
     throws ->
     [String: Any] {
         var foreignKeyInfo: [String: Any] = [:]
         // Define the regular expression patterns for extracting the
         // FOREIGN KEY clause and composite primary keys
-        let foreignKeyPattern = #"\bFOREIGN\s+KEY\s*\(([^)]+)\)\s+REFERENCES\s+(\w+)\s*\(([^)]+)\)\s+(ON\s+DELETE\s+(RESTRICT|CASCADE|SET\s+NULL|SET\s+DEFAULT|NO\s+ACTION))?"#
-
+        let foreignKeyPattern = #"""
+            \bFOREIGN\s+KEY\s*\(([^)]+)\)\s+
+            REFERENCES\s+(\w+)\s*\(([^)]+)\)\s+
+            (ON\s+DELETE\s+(RESTRICT|CASCADE|SET\s+NULL|SET\s+DEFAULT|NO\s+ACTION))?
+            """#
         // Create a regular expression object
         guard let regex = try? NSRegularExpression(
                 pattern: foreignKeyPattern, options: []) else {
@@ -224,8 +335,7 @@ class UtilsSQLStatement {
         foreignKeyInfo["action"] = "NO_ACTION"
         return foreignKeyInfo
     }
-    // swiftlint:enable type_body_length
-    // swiftlint:disable function_body_length
+    // swiftlint:enable function_body_length
 
     // MARK: - extractColumnNames
 
@@ -266,7 +376,7 @@ class UtilsSQLStatement {
             }
         }
 
-        func processToken(_ token: String) {
+/*        func processToken(_ token: String) {
             if token.uppercased() == "IN" {
                 inClause = true
             } else if inClause && (token.prefix(7).uppercased() == "(VALUES" ||
@@ -307,6 +417,82 @@ class UtilsSQLStatement {
                 inLike = false
             }
         }
+        */
+        // swiftlint:disable cyclomatic_complexity
+        func processToken(_ token: String) {
+            if token.uppercased() == "IN" {
+                processIn(token)
+            } else if inClause && (token.prefix(7).uppercased() == "(VALUES" ||
+                                    token.prefix(8).uppercased() == "( VALUES") {
+                processInValues(token)
+            } else if inValues && (token.suffix(2).uppercased() == "))" ||
+                                    token.suffix(3).uppercased() == ") )") {
+                processEndInValues(token)
+            } else if inClause && !inValues && token.prefix(1) == "(" {
+                inPar = true
+            } else if inClause && !inValues && token.suffix(1) == ")" {
+                processEndInClause()
+            } else if token.uppercased() == "BETWEEN" {
+                betweenClause = true
+            } else if betweenClause && token.uppercased() == "AND" {
+                andClause = true
+            } else if operators.contains(token) {
+                inOper = true
+            } else if token.uppercased() == "LIKE" {
+                inLike = true
+            } else if shouldProcessColumn(token) {
+                processColumn(token)
+            } else if betweenClause && andClause {
+                processEndBetweenAnd()
+            } else if inOper {
+                processEndInOper()
+            } else if inLike {
+                processEndInLike()
+            }
+        }
+        // swiftlint:enable cyclomatic_complexity
+
+        func processIn(_ token: String) {
+            inClause = true
+        }
+
+        func processInValues(_ token: String) {
+            inValues = true
+        }
+
+        func processEndInValues(_ token: String) {
+            inValues = false
+        }
+
+        func processEndInClause() {
+            inPar = false
+            inClause = false
+        }
+
+        func shouldProcessColumn(_ token: String) -> Bool {
+            token.range(of: "\\b[a-zA-Z]\\w*\\b", options: .regularExpression) != nil
+                && !inClause && (!inValues || !inPar)
+                && !betweenClause && !andClause && !inOper && !inLike
+                && !keywords.contains(token.uppercased())
+        }
+
+        func processColumn(_ token: String) {
+            var mToken = extractString(from: token)
+            mToken = removeOperatorsAndFollowing(from: mToken)
+            columns.append(mToken)
+        }
+        func processEndBetweenAnd() {
+            betweenClause = false
+            andClause = false
+        }
+
+        func processEndInOper() {
+            inOper = false
+        }
+
+        func processEndInLike() {
+            inLike = false
+        }
         let tokens = whereClause.components(separatedBy: CharacterSet(charactersIn: " ,"))
         for token in tokens {
             processToken(token)
@@ -325,84 +511,91 @@ class UtilsSQLStatement {
 
     // MARK: - isReturning
 
-    class func isReturning(sqlStmt: String) -> (Bool, String, String) {
-        let stmtType = sqlStmt
-                .trimmingCharacters(in: .whitespacesAndNewlines)
-                .components(separatedBy: " ")
-                .first?.capitalized ?? ""
-        var stmt = sqlStmt.trimmingCharacters(in: .whitespacesAndNewlines)
-        if stmt.hasSuffix(";") {
-            // Remove the suffix
-            stmt = String(stmt.dropLast())
-                .trimmingCharacters(in: .whitespacesAndNewlines)
-        }
-
+    class func isReturning(sqlStmt: String) -> SQLStatementInfo {
+        let stmtType = getStatementType(sqlStmt)
+        let stmt = cleanStatement(sqlStmt)
         switch stmtType {
-
         case "INSERT":
-            if let valuesIndex = stmt.range(of: "VALUES", options: .caseInsensitive)?.lowerBound,
-               let closingParenthesisIndex = stmt
-               .range(of: ")", options: .backwards, range: valuesIndex..<stmt.endIndex)?
-               .upperBound {
-                guard closingParenthesisIndex < stmt.endIndex else {
-                    stmt += ";"
-                    return (false, stmt, "")
-                }
-
-                let intParenthesisValue = stmt.distance(from: stmt.startIndex, to: closingParenthesisIndex)
-                let substringAfterValues = stmt[closingParenthesisIndex...]
-                var resultString = String(substringAfterValues)
-                    .trimmingCharacters(in: .whitespacesAndNewlines)
-                if resultString.count > 0 && !resultString.hasSuffix(";") {
-                    resultString += ";"
-                }
-
-                let substringStartToEndParenthesis = stmt[...closingParenthesisIndex]
-                let stmtString = String(substringStartToEndParenthesis)
-                    .trimmingCharacters(in: .whitespacesAndNewlines)
-                    .appending(";")
+            return processInsertStatement(sqlStmt, stmt: stmt)
+        case "DELETE", "UPDATE":
+            return processDeleteOrUpdateStatement(sqlStmt, stmt: stmt)
+        default:
+            return SQLStatementInfo(isReturning: false, stmtString: sqlStmt, resultString: "")
+        }
+    }
+    class func getStatementType(_ sqlStmt: String) -> String {
+        let trimmedStmt = sqlStmt.trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmedStmt.components(separatedBy: " ").first?.uppercased() ?? ""
+    }
 
-                if substringAfterValues.lowercased().contains("returning") {
-                    return (true, stmtString, resultString)
-                } else {
-                    return (false, sqlStmt, "")
-                }
+    class func cleanStatement(_ sqlStmt: String) -> String {
+        var cleanedStmt = sqlStmt.trimmingCharacters(in: .whitespacesAndNewlines)
+        if cleanedStmt.hasSuffix(";") {
+            cleanedStmt = String(cleanedStmt.dropLast())
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+        }
+        return cleanedStmt
+    }
+    class func processInsertStatement(_ sqlStmt: String, stmt: String) -> SQLStatementInfo {
+        if let valuesIndex = stmt.range(of: "VALUES", options: .caseInsensitive)?.lowerBound,
+            let closingParenthesisIndex = stmt
+            .range(of: ")", options: .backwards, range: valuesIndex..<stmt.endIndex)?
+            .upperBound {
+            var mStmt = stmt
+            guard closingParenthesisIndex < mStmt.endIndex else {
+                mStmt += ";"
+                return SQLStatementInfo(isReturning: false, stmtString: mStmt, resultString: "")
             }
-            return (false, sqlStmt, "")
 
-        case "DELETE", "UPDATE":
-            let words = stmt.components(separatedBy: .whitespacesAndNewlines)
-            var wordsBeforeReturning: [String] = []
-            var returningString: [String] = []
-
-            var isReturningOutsideMessage = false
-            for word in words {
-                if word.lowercased() == "returning" {
-                    isReturningOutsideMessage = true
-                    // Include "RETURNING" and the words after it in returningString
-                    returningString.append(contentsOf: [word] + UtilsSQLStatement.wordsAfter(word, in: words))
-                    break
-                }
-                wordsBeforeReturning.append(word)
+            let intParenthesisValue = mStmt.distance(from: mStmt.startIndex, to: closingParenthesisIndex)
+            let substringAfterValues = stmt[closingParenthesisIndex...]
+            var resultString = String(substringAfterValues)
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            if resultString.count > 0 && !resultString.hasSuffix(";") {
+                resultString += ";"
             }
 
-            if isReturningOutsideMessage {
-                let joinedWords = wordsBeforeReturning.joined(separator: " ") + ";"
-                var joinedReturningString = returningString.joined(separator: " ")
-                if joinedReturningString.count > 0 &&
-                    !joinedReturningString.hasSuffix(";") {
-                    joinedReturningString += ";"
-                }
+            let substringStartToEndParenthesis = mStmt[...closingParenthesisIndex]
+            let stmtString = String(substringStartToEndParenthesis)
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+                .appending(";")
 
-                return (true, joinedWords, joinedReturningString)
+            if substringAfterValues.lowercased().contains("returning") {
+                return SQLStatementInfo(isReturning: true, stmtString: stmtString, resultString: resultString)
             } else {
-                return (false, sqlStmt, "")
+                return SQLStatementInfo(isReturning: false, stmtString: sqlStmt, resultString: "")
             }
+        }
+        return SQLStatementInfo(isReturning: false, stmtString: sqlStmt, resultString: "")
+    }
 
-        default:
-            return (false, sqlStmt, "")
+    class func processDeleteOrUpdateStatement(_ sqlStmt: String, stmt: String) -> SQLStatementInfo {
+        let words = stmt.components(separatedBy: .whitespacesAndNewlines)
+        var wordsBeforeReturning: [String] = []
+        var returningString: [String] = []
+
+        var isReturningOutsideMessage = false
+        for word in words {
+            if word.lowercased() == "returning" {
+                isReturningOutsideMessage = true
+                // Include "RETURNING" and the words after it in returningString
+                returningString.append(contentsOf: [word] + UtilsSQLStatement.wordsAfter(word, in: words))
+                break
+            }
+            wordsBeforeReturning.append(word)
         }
 
+        if isReturningOutsideMessage {
+            let joinedWords = wordsBeforeReturning.joined(separator: " ") + ";"
+            var joinedReturningString = returningString.joined(separator: " ")
+            if joinedReturningString.count > 0 &&
+                !joinedReturningString.hasSuffix(";") {
+                joinedReturningString += ";"
+            }
+            return SQLStatementInfo(isReturning: true, stmtString: joinedWords, resultString: joinedReturningString)
+        } else {
+            return SQLStatementInfo(isReturning: false, stmtString: sqlStmt, resultString: "")
+        }
     }
 
     // MARK: - wordsAfter
@@ -420,13 +613,13 @@ class UtilsSQLStatement {
     -> [String: String] {
         var retStmtNames: [String: String] = [:]
 
-        let (isReturning, stmt, suffix) = isReturning(sqlStmt: sqlStmt)
-        retStmtNames["stmt"] = stmt
+        let statementInfo = isReturning(sqlStmt: sqlStmt)
+        retStmtNames["stmt"] = statementInfo.stmtString
         retStmtNames["names"] = ""
-        if isReturning && retMode.prefix(2) == "wA" {
-            let lowercaseSuffix = suffix.lowercased()
+        if statementInfo.isReturning && retMode.prefix(2) == "wA" {
+            let lowercaseSuffix = statementInfo.resultString.lowercased()
             if let returningIndex = lowercaseSuffix.range(of: "returning") {
-                let substring = suffix[returningIndex.upperBound...]
+                let substring = statementInfo.resultString[returningIndex.upperBound...]
 
                 let names =
                     "\(substring)".trimmingLeadingAndTrailingSpaces()
@@ -437,13 +630,13 @@ class UtilsSQLStatement {
     }
 
     // MARK: - getNames
-    
+
     class func getNames(from input: String) -> String {
         // Find the index of the first occurrence of ";", "--", or "/*"
         let indexSemicolon = input.firstIndex(of: ";")
         let indexDoubleDash = input.range(of: "--")
         let indexCommentStart = input.range(of: "/*")
-        
+
         // Find the minimum index among them
         var minIndex = input.endIndex
         if let index = indexSemicolon {
@@ -455,12 +648,12 @@ class UtilsSQLStatement {
         if let index = indexCommentStart?.lowerBound {
             minIndex = min(minIndex, index)
         }
-        
+
         // Extract substring up to the minimum index
         let colnames = String(input[..<minIndex]).trimmingCharacters(in: .whitespacesAndNewlines)
         return colnames
     }
-    
+
     // MARK: - extractCombinedPrimaryKey
 
     class func extractCombinedPrimaryKey(from whereClause: String)
@@ -485,8 +678,8 @@ class UtilsSQLStatement {
 
             if let keysRange = Range(match.range(at: 1), in: whereClause) {
                 let keysString = String(whereClause[keysRange])
-                let keys = keysString.split(separator: ",").map {
-                    String($0.trimmingCharacters(in: .whitespaces)) }
+                let keys = keysString.split(separator: ",").map({
+                    String($0.trimmingCharacters(in: .whitespaces)) })
                 primaryKeySets.append(keys)
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor-community/sqlite",
-  "version": "5.7.1",
+  "version": "5.7.3-1",
   "description": "Community plugin for native & electron SQLite databases",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -59,11 +59,11 @@
     "prepublishOnly": "npm run build && npm run build-electron && npm run docgen"
   },
   "devDependencies": {
-    "@capacitor/android": "^5.7.1",
-    "@capacitor/cli": "^5.7.1",
-    "@capacitor/core": "^5.7.1",
+    "@capacitor/android": "^5.7.3",
+    "@capacitor/cli": "^5.7.3",
+    "@capacitor/core": "^5.7.3",
     "@capacitor/docgen": "^0.0.17",
-    "@capacitor/ios": "^5.7.1",
+    "@capacitor/ios": "^5.7.3",
     "@ionic/eslint-config": "^0.3.0",
     "@ionic/prettier-config": "^1.0.1",
     "@ionic/swiftlint-config": "^1.1.2",
@@ -74,7 +74,7 @@
     "prettier-plugin-java": "~1.0.2",
     "rimraf": "^3.0.2",
     "rollup": "^2.32.0",
-    "swiftlint": "^1.0.1",
+    "swiftlint": "^1.0.2",
     "typescript": "~4.1.5"
   },
   "peerDependencies": {
@@ -97,6 +97,6 @@
     }
   },
   "dependencies": {
-    "jeep-sqlite": "^2.6.2"
+    "jeep-sqlite": "^2.7.0"
   }
 }

package/src/web.ts

@@ -45,7 +45,7 @@ export class CapacitorSQLiteWeb
   private isWebStoreOpen = false;
 
   async initWebStore(): Promise<void> {
-    customElements.whenDefined('jeep-sqlite').then(async () => {
+     await customElements.whenDefined('jeep-sqlite')
 
       this.jeepSqliteElement = document.querySelector('jeep-sqlite');
       this.ensureJeepSqliteIsAvailable();
@@ -86,7 +86,6 @@ export class CapacitorSQLiteWeb
       }
 
       return;
-    });
   }
 
   async saveToStore(options: capSQLiteOptions): Promise<void> {