@capgo/capacitor-fast-sql 8.2.16 → 8.2.17

package/ios/Sources/CapgoCapacitorFastSqlPlugin/CapgoCapacitorFastSqlPlugin.swift

@@ -10,7 +10,7 @@ import SQLite3
  */
 @objc(CapgoCapacitorFastSqlPlugin)
 public class CapgoCapacitorFastSqlPlugin: CAPPlugin, CAPBridgedPlugin {
-    private let pluginVersion: String = "8.2.16"
+    private let pluginVersion: String = "8.2.17"
     public let identifier = "CapgoCapacitorFastSqlPlugin"
     public let jsName = "CapgoCapacitorFastSql"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -44,7 +44,11 @@ public class CapgoCapacitorFastSqlPlugin: CAPPlugin, CAPBridgedPlugin {
         }
 
         // Check if already connected
-        if databases[database] != nil {
+        if let existing = databases[database] {
+            guard existing.isReadOnly == (call.getBool("readOnly") ?? false) else {
+                call.reject("Database is already open with a different readOnly option")
+                return
+            }
             if let server = server {
                 call.resolve([
                     "port": server.port,
@@ -63,6 +67,7 @@ public class CapgoCapacitorFastSqlPlugin: CAPPlugin, CAPBridgedPlugin {
             let db = try SQLDatabase(
                 path: dbPath,
                 encrypted: encrypted,
+                readOnly: call.getBool("readOnly") ?? false,
                 encryptionKey: encryptionKey,
                 walMode: walMode,
                 performancePresets: performancePresets
@@ -177,6 +182,10 @@ public class CapgoCapacitorFastSqlPlugin: CAPPlugin, CAPBridgedPlugin {
     }
 
     @objc func beginTransaction(_ call: CAPPluginCall) {
+        guard (call.getString("isolationLevel") ?? "SERIALIZABLE") == "SERIALIZABLE" else {
+            call.reject("Only SERIALIZABLE transaction isolation is supported")
+            return
+        }
         guard let database = call.getString("database") else {
             call.reject("Database name is required")
             return
@@ -245,6 +254,12 @@ public class CapgoCapacitorFastSqlPlugin: CAPPlugin, CAPBridgedPlugin {
     }
 
     private func getDatabasePath(_ database: String) throws -> String {
+        guard !database.isEmpty, database != ".", database != "..",
+              !database.contains("/"), !database.contains("\\"), !database.contains("\0") else {
+            throw NSError(domain: "CapgoCapacitorFastSQL", code: 2, userInfo: [
+                NSLocalizedDescriptionKey: "Database must be a non-empty file name without path separators"
+            ])
+        }
         let paths = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)
         guard let documentsDirectory = paths.first else {
             throw NSError(domain: "CapgoCapacitorFastSQL", code: 1, userInfo: [
@@ -253,6 +268,13 @@ public class CapgoCapacitorFastSqlPlugin: CAPPlugin, CAPBridgedPlugin {
         }
 
         let dbPath = (documentsDirectory as NSString).appendingPathComponent("\(database).db")
-        return dbPath
+        let root = URL(fileURLWithPath: documentsDirectory).resolvingSymlinksInPath().standardizedFileURL
+        let resolved = URL(fileURLWithPath: dbPath).resolvingSymlinksInPath().standardizedFileURL
+        guard resolved.deletingLastPathComponent().path == root.path else {
+            throw NSError(domain: "CapgoCapacitorFastSQL", code: 2, userInfo: [
+                NSLocalizedDescriptionKey: "Database path must remain inside app storage"
+            ])
+        }
+        return resolved.path
     }
 }

package/ios/Sources/CapgoCapacitorFastSqlPlugin/SQLDatabase.swift

@@ -13,6 +13,7 @@ private let sqliteTransient = unsafeBitCast(-1, to: sqlite3_destructor_type.self
  * SQLite database wrapper for iOS
  */
 class SQLDatabase {
+    let isReadOnly: Bool
     private var db: OpaquePointer?
     private let path: String
     private var inTransaction = false
@@ -20,13 +21,15 @@ class SQLDatabase {
     init(
         path: String,
         encrypted: Bool = false,
+        readOnly: Bool = false,
         encryptionKey: String? = nil,
         walMode: Bool = false,
         performancePresets: Bool = false
     ) throws {
         self.path = path
+        self.isReadOnly = readOnly
 
-        let flags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE | SQLITE_OPEN_FULLMUTEX
+        let flags = (readOnly ? SQLITE_OPEN_READONLY : SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE) | SQLITE_OPEN_FULLMUTEX
         let result = sqlite3_open_v2(path, &db, flags, nil)
 
         guard result == SQLITE_OK else {
@@ -64,7 +67,7 @@ class SQLDatabase {
             #endif
         }
 
-        try applyPerformanceOptions(walMode: walMode, performancePresets: performancePresets)
+        try applyPerformanceOptions(walMode: walMode && !readOnly, performancePresets: performancePresets)
         needsClose = false
     }
 
@@ -148,8 +151,9 @@ class SQLDatabase {
             }
         }
 
-        let changes = sqlite3_changes(db)
-        let lastInsertId = sqlite3_last_insert_rowid(db)
+        let readOnly = sqlite3_stmt_readonly(stmt) != 0
+        let changes = readOnly ? 0 : sqlite3_changes(db)
+        let lastInsertId = readOnly ? 0 : sqlite3_last_insert_rowid(db)
 
         return [
             "rows": rows,
@@ -211,7 +215,10 @@ class SQLDatabase {
                   type == "binary",
                   let base64 = dict["_data"] as? String,
                   let data = Data(base64Encoded: base64) {
-            // Handle binary data
+            // SQLite treats a null blob pointer as SQL NULL, even with length zero.
+            if data.isEmpty {
+                return sqlite3_bind_zeroblob(stmt, index, 0)
+            }
             return data.withUnsafeBytes { (bytes: UnsafeRawBufferPointer) in
                 sqlite3_bind_blob(stmt, index, bytes.baseAddress, Int32(data.count), sqliteTransient)
             }
@@ -238,6 +245,9 @@ class SQLDatabase {
             }
             return NSNull()
         case SQLITE_BLOB:
+            if sqlite3_column_bytes(stmt, index) == 0 {
+                return ["_type": "binary", "_data": ""]
+            }
             if let blob = sqlite3_column_blob(stmt, index) {
                 let size = sqlite3_column_bytes(stmt, index)
                 let data = Data(bytes: blob, count: Int(size))

package/ios/Sources/CapgoCapacitorFastSqlPlugin/SQLHTTPServer.swift

@@ -283,6 +283,12 @@ class SQLHTTPServer {
     }
 
     private func handleBeginTransactionRequest(request: HTTPRequest) -> HTTPResponse {
+        if !request.body.isEmpty {
+            guard let body = try? JSONSerialization.jsonObject(with: request.body) as? [String: Any],
+                  (body["isolationLevel"] as? String ?? "SERIALIZABLE") == "SERIALIZABLE" else {
+                return HTTPResponse(.badRequest, body: Data("Only SERIALIZABLE transaction isolation is supported".utf8))
+            }
+        }
         // Authenticate
         guard let authHeader = request.headers["Authorization"],
               authHeader == "Bearer \(token)" else {

package/ios/Tests/CapgoCapacitorFastSqlPluginTests/CapgoCapacitorFastSqlPluginTests.swift

@@ -2,8 +2,18 @@ import XCTest
 @testable import CapgoCapacitorFastSqlPlugin
 
 final class CapgoCapacitorFastSqlPluginTests: XCTestCase {
-    func testExample() throws {
-        // This is an example of a functional test case.
-        XCTAssertTrue(true)
+    func testEmptyBlobRemainsDistinctFromNull() throws {
+        let database = try SQLDatabase(path: ":memory:")
+        defer { database.close() }
+        let result = try database.execute(
+            statement: "SELECT typeof(?) AS kind, ? AS value, NULL AS missing",
+            params: [["_type": "binary", "_data": ""], ["_type": "binary", "_data": ""]]
+        )
+        let rows = try XCTUnwrap(result["rows"] as? [[String: Any]])
+        XCTAssertEqual(rows.first?["kind"] as? String, "blob")
+        let value = try XCTUnwrap(rows.first?["value"] as? [String: String])
+        XCTAssertEqual(value["_type"], "binary")
+        XCTAssertEqual(value["_data"], "")
+        XCTAssertTrue(rows.first?["missing"] is NSNull)
     }
 }

package/ios/Tests/CapgoCapacitorFastSqlPluginTests/SQLResultMetadataTests.swift

@@ -0,0 +1,15 @@
+import XCTest
+@testable import CapgoCapacitorFastSqlPlugin
+
+final class SQLResultMetadataTests: XCTestCase {
+    func testSelectDoesNotInheritPreviousInsertMetadata() throws {
+        let database = try SQLDatabase(path: ":memory:")
+        defer { database.close() }
+        _ = try database.execute(statement: "CREATE TABLE sample (id INTEGER PRIMARY KEY)", params: [])
+        let inserted = try database.execute(statement: "INSERT INTO sample DEFAULT VALUES", params: [])
+        XCTAssertEqual(inserted["rowsAffected"] as? Int32, 1)
+        let selected = try database.execute(statement: "SELECT id FROM sample", params: [])
+        XCTAssertEqual(selected["rowsAffected"] as? Int32, 0)
+        XCTAssertTrue(selected["insertId"] is NSNull)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-fast-sql",
-  "version": "8.2.16",
+  "version": "8.2.17",
   "description": "High-performance native SQLite plugin with custom protocol for efficient sync operations and IndexedDB replacement",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",