@capacitor-community/sqlite 5.5.1-3 → 5.5.1

package/ios/Plugin/CapacitorSQLite.swift

@@ -1547,7 +1547,10 @@ enum CapacitorSQLiteError: Error {
             let aPath: String = try (UtilsFile.getFolderURL(folderPath: databaseLocation)).path
             // get the database files
             let dbList: [String] = try UtilsFile.getFileList(path: aPath, ext: ".db")
-            return dbList
+            // filter for db including SQLite
+            let dbWithSQLite = dbList.filter { $0.contains("SQLite") }
+
+            return dbWithSQLite
 
         } catch let error {
             let msg: String = "\(error)"
@@ -1564,7 +1567,10 @@ enum CapacitorSQLiteError: Error {
         do {
             let dbList: [String] = try UtilsMigrate
                 .getMigratableList(folderPath: folderPath)
-            return dbList
+            // filter for db not including SQLite
+            let dbNoSQLite = dbList.filter { !$0.contains("SQLite") }
+
+            return dbNoSQLite
 
         } catch UtilsMigrateError.getMigratableList(let message) {
             var msg: String = "getMigratableList:"

package/ios/Plugin/Database.swift

@@ -688,6 +688,8 @@ class Database {
             if isExists {
                 // Set the last exported date
                 try ExportToJson.setLastExportDate(mDB: self, sTime: syncTime)
+            } else {
+                throw DatabaseError.exportToJson(message: "No sync_table available")
             }
             // Launch the export process
             let data: [String: Any] = [

package/ios/Plugin/Utils/UtilsSQLCipher.swift

@@ -447,7 +447,7 @@ class UtilsSQLCipher {
             msg.append("Database not opened")
             throw UtilsSQLCipherError.prepareSQL(message: msg)
         }
-        let systemVersion = UIDevice.current.systemVersion
+//        let systemVersion = UIDevice.current.systemVersion
         var runSQLStatement: OpaquePointer?
         var message: String = ""
         var lastId: Int64 = -1
@@ -463,9 +463,7 @@ class UtilsSQLCipher {
                 retMode = "wA\(retMode)"
             }
         }
-
-        if (retMode == "no" || retMode.prefix(2) == "wA") &&
-            sqlStmt.uppercased().contains("RETURNING") {
+        if (retMode == "no" || retMode.prefix(2) == "wA")/* && isReturning*/ {
             let stmtNames = UtilsSQLStatement
                 .getStmtAndRetColNames(sqlStmt: sqlStmt,
                                        retMode: retMode)
@@ -556,6 +554,7 @@ class UtilsSQLCipher {
             return (lastId, result)
         }
     }
+    
 
     // MARK: - returningWorkAround
 

package/ios/Plugin/Utils/UtilsSQLStatement.swift

@@ -323,28 +323,114 @@ class UtilsSQLStatement {
         return lines.joined(separator: " ")
     }
 
+    // MARK: - isReturning
+
+    class func isReturning(sqlStmt: String) -> (Bool, String, String) {
+        var stmt = sqlStmt.replacingOccurrences(of: "\n", with: "")
+                          .trimmingCharacters(in: .whitespacesAndNewlines)
+        if stmt.hasSuffix(";") {
+            // Remove the suffix
+            stmt = String(stmt.dropLast())
+                        .trimmingCharacters(in: .whitespacesAndNewlines)
+        }
+
+        switch (stmt.prefix(6).uppercased())  {
+            
+          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(";")
+
+                    if substringAfterValues.lowercased().contains("returning") {
+                        return (true,stmtString,resultString)
+                    } else {
+                        return (false, stmt, "")
+                    }
+                }
+                return (false, stmt, "")
+            
+            
+          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)
+            }
+
+            if isReturningOutsideMessage {
+                let joinedWords = wordsBeforeReturning.joined(separator: " ") + ";"
+                var joinedReturningString = returningString.joined(separator: " ")
+                if joinedReturningString.count > 0 &&
+                            !joinedReturningString.hasSuffix(";") {
+                    joinedReturningString += ";"
+                }
+
+                return (true, joinedWords, joinedReturningString)
+            } else {
+                return (false, stmt, "")
+            }
+            
+          default:
+            return (false, stmt, "")
+        }
+        
+    }
+
+    // MARK: - wordsAfter
+
+    class func wordsAfter(_ word: String, in words: [String]) -> [String] {
+        guard let index = words.firstIndex(of: word) else {
+            return []
+        }
+        return Array(words.suffix(from: index + 1))
+    }
+    
     // MARK: - getStmtAndRetColNames
 
     class func getStmtAndRetColNames(sqlStmt: String, retMode: String)
     -> [String: String] {
-        let retWord = "RETURNING"
-
         var retStmtNames: [String: String] = [:]
-        retStmtNames["stmt"] = sqlStmt
+        
+        let (isReturning, stmt, suffix) = isReturning(sqlStmt: sqlStmt)
+        retStmtNames["stmt"] = stmt
         retStmtNames["names"] = ""
-        if let range = sqlStmt.uppercased().range(of: retWord) {
-            let prefix = sqlStmt.prefix(upTo: range.lowerBound)
-            retStmtNames["stmt"] = "\(prefix);"
-            retStmtNames["names"] = ""
-            if retMode.prefix(2) == "wA" {
-                let suffix = sqlStmt.suffix(from: range.upperBound)
+        if isReturning && retMode.prefix(2) == "wA" {
+            let lowercaseSuffix = suffix.lowercased()
+            if let returningIndex = lowercaseSuffix.range(of: "returning") {
+                let substring = suffix[returningIndex.upperBound...]
+
                 let names =
-                    "\(suffix)".trimmingLeadingAndTrailingSpaces()
+                "\(substring)".trimmingLeadingAndTrailingSpaces()
                 if names.suffix(1) == ";" {
                     retStmtNames["names"] = String(names.dropLast())
                 }
             }
-
         }
         return retStmtNames
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor-community/sqlite",
-  "version": "5.5.1-3",
+  "version": "5.5.1",
   "description": "Community plugin for native & electron SQLite databases",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -97,6 +97,6 @@
     }
   },
   "dependencies": {
-    "jeep-sqlite": "^2.5.5"
+    "jeep-sqlite": "^2.5.7"
   }
 }

package/src/definitions.ts

@@ -2207,30 +2207,24 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
     try {
       if (!this.readonly) {
         if (values && values.length > 0) {
-          const mRetMode = statement.toUpperCase().includes('RETURNING')
-            ? returnMode
-            : 'no';
+
           res = await this.sqlite.run({
             database: this.dbName,
             statement: statement,
             values: values,
             transaction: transaction,
             readonly: false,
-            returnMode: mRetMode,
+            returnMode: returnMode,
             isSQL92: true,
           });
-          //        }
         } else {
-          const mRetMode = statement.toUpperCase().includes('RETURNING')
-            ? returnMode
-            : 'no';
           res = await this.sqlite.run({
             database: this.dbName,
             statement: statement,
             values: [],
             transaction: transaction,
             readonly: false,
-            returnMode: mRetMode,
+            returnMode: returnMode,
             isSQL92: isSQL92,
           });
         }