@trainstar/synchro-react-native 0.4.0-rc.2 → 0.4.0-rc.4

package/ios/SynchroOwnership.swift

@@ -0,0 +1,173 @@
+import Foundation
+import os
+import React
+
+/// Values that can cross wrapper execution boundaries without carrying Foundation containers.
+enum BridgeValue: Sendable {
+    case null
+    case bool(Bool)
+    case integer(Int64)
+    case double(Double)
+    case string(String)
+    case array([BridgeValue])
+    case object([String: BridgeValue])
+
+    func foundationValue() -> Any {
+        switch self {
+        case .null:
+            return NSNull()
+        case .bool(let value):
+            return NSNumber(value: value)
+        case .integer(let value):
+            return NSNumber(value: value)
+        case .double(let value):
+            return NSNumber(value: value)
+        case .string(let value):
+            return value
+        case .array(let values):
+            return values.map { $0.foundationValue() }
+        case .object(let values):
+            return values.mapValues { $0.foundationValue() }
+        }
+    }
+}
+
+enum BridgePromiseValue: Sendable {
+    case void
+    case value(BridgeValue)
+}
+
+/// Owns the imported React promise blocks and settles them exactly once.
+///
+/// React Native copies these blocks for an escaping module invocation. Its TurboModule
+/// implementation protects its shared resolve/reject state with a mutex and schedules
+/// JavaScript through `AsyncCallback`. React Native also permits native callbacks from
+/// any queue. Swift cannot express those Objective-C runtime guarantees as `Sendable`.
+final class ReactPromiseSettlement: @unchecked Sendable {
+    private let lock = NSLock()
+    private var resolveBlock: RCTPromiseResolveBlock?
+    private var rejectBlock: RCTPromiseRejectBlock?
+
+    init(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        resolveBlock = resolve
+        rejectBlock = reject
+    }
+
+    @discardableResult
+    func resolve(_ value: BridgePromiseValue) -> Bool {
+        lock.lock()
+        guard let resolveBlock else {
+            lock.unlock()
+            return false
+        }
+        self.resolveBlock = nil
+        rejectBlock = nil
+        lock.unlock()
+
+        switch value {
+        case .void:
+            resolveBlock(nil)
+        case .value(let value):
+            resolveBlock(value.foundationValue())
+        }
+        return true
+    }
+
+    @discardableResult
+    func reject(_ code: String?, _ message: String?, _ error: Error?) -> Bool {
+        lock.lock()
+        guard let rejectBlock else {
+            lock.unlock()
+            return false
+        }
+        resolveBlock = nil
+        self.rejectBlock = nil
+        lock.unlock()
+
+        rejectBlock(code, message, error)
+        return true
+    }
+}
+
+/// Owns the Objective-C event target without creating an implementation cycle.
+///
+/// The delegate is installed by Objective-C++, can be released outside Swift, and is
+/// invoked only on main. The lock protects the weak reference, not callback execution.
+final class ReactEventTarget: @unchecked Sendable {
+    private let lock = NSLock()
+    private weak var delegate: SynchroEventEmitting?
+
+    var currentDelegate: SynchroEventEmitting? {
+        lock.lock()
+        defer { lock.unlock() }
+        return delegate
+    }
+
+    func setDelegate(_ delegate: SynchroEventEmitting?) {
+        lock.lock()
+        self.delegate = delegate
+        lock.unlock()
+    }
+
+    func emit(_ name: String, body: BridgeValue) {
+        DispatchQueue.main.async { [self, name, body] in
+            lock.lock()
+            let delegate = self.delegate
+            lock.unlock()
+            guard let payload = body.foundationValue() as? NSDictionary else {
+                preconditionFailure("Event payload must be an object")
+            }
+            delegate?.emitEvent(name, body: payload)
+        }
+    }
+}
+
+final class AuthRequestStore: Sendable {
+    private struct State: Sendable {
+        var acceptsRequests = false
+        var continuations: [String: CheckedContinuation<String, Error>] = [:]
+    }
+
+    private let state = OSAllocatedUnfairLock(initialState: State())
+
+    func activate() {
+        state.withLock { $0.acceptsRequests = true }
+    }
+
+    func insert(_ continuation: CheckedContinuation<String, Error>, for requestID: String) -> Bool {
+        state.withLock { state in
+            guard state.acceptsRequests else { return false }
+            state.continuations[requestID] = continuation
+            return true
+        }
+    }
+
+    func resolve(_ requestID: String, token: String) {
+        let continuation = state.withLock { $0.continuations.removeValue(forKey: requestID) }
+        continuation?.resume(returning: token)
+    }
+
+    func reject(_ requestID: String, error: Error) {
+        let continuation = state.withLock { $0.continuations.removeValue(forKey: requestID) }
+        continuation?.resume(throwing: error)
+    }
+
+    func cancelAll() {
+        let continuations = state.withLock { state in
+            state.acceptsRequests = false
+            let continuations = Array(state.continuations.values)
+            state.continuations.removeAll()
+            return continuations
+        }
+        let error = NSError(
+            domain: "SynchroModule",
+            code: 0,
+            userInfo: [NSLocalizedDescriptionKey: "client closed"]
+        )
+        continuations.forEach { $0.resume(throwing: error) }
+    }
+
+    var count: Int {
+        state.withLock { $0.continuations.count }
+    }
+}

package/ios-test-host/{main.m → AppDelegate.m}

@@ -39,10 +39,3 @@
 }
 
 @end
-
-int main(int argc, char *argv[])
-{
-    @autoreleasepool {
-        return UIApplicationMain(argc, argv, nil, NSStringFromClass([SynchroTestHostAppDelegate class]));
-    }
-}

package/ios-test-host/main.swift

@@ -0,0 +1,12 @@
+import Darwin
+import UIKit
+
+let status = autoreleasepool {
+    UIApplicationMain(
+        CommandLine.argc,
+        CommandLine.unsafeArgv,
+        nil,
+        "SynchroTestHostAppDelegate"
+    )
+}
+exit(status)

package/ios-tests/SynchroModuleTransactionTests.swift

@@ -4,6 +4,7 @@ import Synchro
 import XCTest
 
 private let settlementTimeout: TimeInterval = 60
+private let promptDispatchTimeout: TimeInterval = 4
 private let sqliteTransient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
 private let columnsJSON = #"[{"name":"id","type":"TEXT","primaryKey":true},{"name":"name","type":"TEXT"}]"#
 private let insertSQL = "INSERT INTO bridge_items (id, name) VALUES (?, ?)"
@@ -243,6 +244,7 @@ final class SynchroModuleTransactionTests: XCTestCase {
     private var events: EventRecorder!
     private var cleanup: CleanupState!
     private var databasePath: String!
+    private var externalConnections: [ExternalConnection] = []
 
     override func setUpWithError() throws {
         try super.setUpWithError()
@@ -256,32 +258,51 @@ final class SynchroModuleTransactionTests: XCTestCase {
         self.events = events
         self.cleanup = cleanup
         self.databasePath = databasePath
-        // Teardown blocks run in reverse order. This block is first, so every gate a test
-        // registers later is released before close joins the registered transactions.
-        addTeardownBlock {
-            withExtendedLifetime(events) {
-                let close = PromiseRecorder("teardown close")
-                module.close(close.resolve, reject: close.reject)
-                let settled = XCTWaiter().wait(for: [close.firstSettlement], timeout: settlementTimeout) == .completed
-                guard settled, close.resolutions.count == 1, close.rejections.isEmpty else {
-                    XCTFail("teardown close did not resolve once (settled: \(settled), resolutions: \(close.resolutions.count), rejections: \(close.rejections)). Kept \(databasePath).")
-                    return
-                }
-                guard !cleanup.hasFailure else {
-                    XCTFail("a test-owned resource did not close. Kept \(databasePath).")
-                    return
-                }
-                for suffix in ["", "-wal", "-shm"] {
-                    let path = databasePath + suffix
-                    guard FileManager.default.fileExists(atPath: path) else { continue }
-                    do {
-                        try FileManager.default.removeItem(atPath: path)
-                    } catch {
-                        XCTFail("remove \(path): \(error)")
-                    }
+    }
+
+    override func tearDownWithError() throws {
+        let teardownDatabasePath = databasePath ?? "unknown database path"
+        var moduleClosed = false
+        for connection in externalConnections.reversed() {
+            do {
+                try connection.close()
+            } catch {
+                cleanup.recordFailure()
+                XCTFail("close external connection: \(error)")
+            }
+        }
+        externalConnections.removeAll()
+
+        if let module {
+            let close = PromiseRecorder("teardown close")
+            module.close(close.resolve, reject: close.reject)
+            let settled = XCTWaiter().wait(for: [close.firstSettlement], timeout: settlementTimeout) == .completed
+            moduleClosed = settled && close.resolutions.count == 1 && close.rejections.isEmpty
+            if !moduleClosed {
+                XCTFail("teardown close did not resolve once (settled: \(settled), resolutions: \(close.resolutions.count), rejections: \(close.rejections)). Kept \(teardownDatabasePath).")
+            }
+            module.eventDelegate = nil
+        }
+        withExtendedLifetime(events) {}
+
+        if cleanup.hasFailure {
+            XCTFail("a test-owned resource did not close. Kept \(teardownDatabasePath).")
+        } else if moduleClosed {
+            for suffix in ["", "-wal", "-shm"] {
+                let path = teardownDatabasePath + suffix
+                guard FileManager.default.fileExists(atPath: path) else { continue }
+                do {
+                    try FileManager.default.removeItem(atPath: path)
+                } catch {
+                    XCTFail("remove \(path): \(error)")
                 }
             }
         }
+        module = nil
+        events = nil
+        cleanup = nil
+        databasePath = nil
+        try super.tearDownWithError()
     }
 
     func testAcquisitionFailureRejectsBeginOnce() throws {
@@ -365,6 +386,213 @@ final class SynchroModuleTransactionTests: XCTestCase {
         XCTAssertEqual(events.names, [])
     }
 
+    func testFourReadersLeaveCapacityForOrdinaryQuery() throws {
+        try initializeModule()
+        let held = try holdReadTransactions(count: 4)
+        let ordinary = settle("ordinary query with four readers") {
+            module.query("SELECT 1", params: [], resolve: $0.resolve, reject: $0.reject)
+        }
+        XCTAssertEqual((try resolvedValue(ordinary) as? [[String: Any]])?.count, 1)
+
+        let commits = try held.ids.enumerated().map { index, txID in
+            let commit = settle("commit reader \(index)") {
+                module.commitTransaction(txID, resolve: $0.resolve, reject: $0.reject)
+            }
+            _ = try resolvedValue(commit)
+            return commit
+        }
+        let close = try closeModule()
+
+        requireSettledOnce(held.recorders + [ordinary] + commits + [close])
+        XCTAssertEqual(events.names, [])
+    }
+
+    func testFiveReadersDoNotBlockOrdinaryQueryAheadOfCommits() throws {
+        try initializeModule()
+        let held = try holdReadTransactions(count: 5)
+        let ordinary = PromiseRecorder("ordinary query with five readers")
+        let commits = held.ids.indices.map { PromiseRecorder("commit reader \($0)") }
+        let module = try XCTUnwrap(self.module)
+
+        let invocationStarted = Date()
+        module.query("SELECT 1", params: [], resolve: ordinary.resolve, reject: ordinary.reject)
+        XCTAssertLessThan(Date().timeIntervalSince(invocationStarted), promptDispatchTimeout)
+        for (index, txID) in held.ids.enumerated() {
+            module.commitTransaction(txID, resolve: commits[index].resolve, reject: commits[index].reject)
+        }
+
+        waitForSettlements([ordinary] + commits, timeout: promptDispatchTimeout)
+        XCTAssertEqual((try resolvedValue(ordinary) as? [[String: Any]])?.count, 1)
+        let close = try closeModule()
+
+        requireSettledOnce(held.recorders + [ordinary] + commits + [close])
+        XCTAssertEqual(events.names, [])
+    }
+
+    func testFiveReadersDoNotBlockOrdinaryQueryOneAheadOfRollbacks() throws {
+        try initializeModule()
+        let held = try holdReadTransactions(count: 5)
+        let ordinary = PromiseRecorder("ordinary query one with five readers")
+        let rollbacks = held.ids.indices.map { PromiseRecorder("rollback reader \($0)") }
+        let module = try XCTUnwrap(self.module)
+
+        let invocationStarted = Date()
+        module.queryOne("SELECT 1", params: [], resolve: ordinary.resolve, reject: ordinary.reject)
+        XCTAssertLessThan(Date().timeIntervalSince(invocationStarted), promptDispatchTimeout)
+        for (index, txID) in held.ids.enumerated() {
+            module.rollbackTransaction(txID, resolve: rollbacks[index].resolve, reject: rollbacks[index].reject)
+        }
+
+        waitForSettlements([ordinary] + rollbacks, timeout: promptDispatchTimeout)
+        XCTAssertEqual((try resolvedValue(ordinary) as? [String: Any])?.count, 1)
+        let close = try closeModule()
+
+        requireSettledOnce(held.recorders + [ordinary] + rollbacks + [close])
+        XCTAssertEqual(events.names, [])
+    }
+
+    func testOrdinaryWriterSurfacesDoNotBlockWriteTransactionCommands() throws {
+        try initializeModule()
+        let module = try XCTUnwrap(self.module)
+        let ordinaryCalls: [(String, (PromiseRecorder) -> Void)] = [
+            ("execute", { recorder in
+                module.execute("SELECT 1", params: [], resolve: recorder.resolve, reject: recorder.reject)
+            }),
+            ("authored write", { recorder in
+                module.executeAuthoredWrite(
+                    "bridge_items",
+                    operation: "update",
+                    columnNames: ["name"],
+                    sql: "SELECT 1",
+                    values: [],
+                    resolve: recorder.resolve,
+                    reject: recorder.reject
+                )
+            }),
+            ("batch", { recorder in
+                module.executeBatch(
+                    [["sql": "SELECT 1", "params": []]],
+                    resolve: recorder.resolve,
+                    reject: recorder.reject
+                )
+            }),
+        ]
+        var recorders: [PromiseRecorder] = []
+
+        for (name, call) in ordinaryCalls {
+            let begin = settle("begin before \(name)") {
+                module.beginWriteTransaction($0.resolve, reject: $0.reject)
+            }
+            let txID = try XCTUnwrap(try resolvedValue(begin) as? String)
+            let probe = settle("transaction query before \(name)") {
+                module.txQuery(txID, sql: "SELECT 1", params: [], resolve: $0.resolve, reject: $0.reject)
+            }
+            let ordinary = PromiseRecorder(name)
+            let commit = PromiseRecorder("commit after \(name)")
+            let invocationStarted = Date()
+            call(ordinary)
+            XCTAssertLessThan(Date().timeIntervalSince(invocationStarted), promptDispatchTimeout, name)
+            module.commitTransaction(txID, resolve: commit.resolve, reject: commit.reject)
+
+            waitForSettlements([ordinary, commit])
+            recorders += [begin, probe, ordinary, commit]
+        }
+
+        let close = try closeModule()
+        requireSettledOnce(recorders + [close])
+        XCTAssertEqual(events.names, [])
+    }
+
+    func testCloseDrainsAdmittedQueryAfterAbortingSaturatedReaders() throws {
+        try initializeModule()
+        let held = try holdReadTransactions(count: 5)
+        let pendingBegin = PromiseRecorder("pending sixth reader")
+        module.beginReadTransaction(pendingBegin.resolve, reject: pendingBegin.reject)
+        let query = PromiseRecorder("admitted query")
+        module.query("SELECT 1", params: [], resolve: query.resolve, reject: query.reject)
+
+        let close = PromiseRecorder("close with admitted query")
+        let recordClose = close.resolve
+        module.close({ value in
+            XCTAssertEqual(pendingBegin.rejections, ["NOT_CONNECTED"])
+            XCTAssertEqual(pendingBegin.settlementCount, 1)
+            XCTAssertEqual(query.settlementCount, 1)
+            recordClose(value)
+        }, reject: close.reject)
+        waitForSettlements([query, pendingBegin, close], timeout: promptDispatchTimeout)
+
+        XCTAssertEqual(query.settlementCount, 1)
+        XCTAssertEqual((try resolvedValue(query) as? [[String: Any]])?.count, 1)
+        requireSettledOnce(held.recorders + [query, close])
+        XCTAssertEqual(pendingBegin.resolutions.count, 0)
+        XCTAssertEqual(pendingBegin.rejections, ["NOT_CONNECTED"])
+        XCTAssertEqual(pendingBegin.settlementCount, 1)
+
+        let afterClose = settle("query after close") {
+            module.query("SELECT 1", params: [], resolve: $0.resolve, reject: $0.reject)
+        }
+        XCTAssertEqual(afterClose.resolutions.count, 0)
+        XCTAssertEqual(afterClose.rejections, ["NOT_CONNECTED"])
+        XCTAssertEqual(afterClose.settlementCount, 1)
+        XCTAssertEqual(events.names, [])
+    }
+
+    func testCloseDrainsQueuedOrdinaryCallsBeforeClosingClient() throws {
+        try initializeModule()
+        let external = try openExternalConnection()
+        let client = try XCTUnwrap(module.client)
+        let hold = ChangeHold()
+        let subscription = client.onChange(tables: ["bridge_items"]) { hold.enter() }
+        addTeardownBlock {
+            hold.release()
+            subscription.cancel()
+        }
+        let activeReader = try holdReadTransactions(count: 1)
+        let id = UUID().uuidString
+
+        let write = PromiseRecorder("held ordinary write")
+        module.execute(insertSQL, params: [id, "ordinary-held"], resolve: write.resolve, reject: write.reject)
+        XCTAssertEqual(XCTWaiter().wait(for: [hold.entered], timeout: settlementTimeout), .completed)
+        XCTAssertEqual(try external.names(id: id), ["ordinary-held"])
+        XCTAssertEqual(write.settlementCount, 0)
+
+        let read = PromiseRecorder("queued ordinary read")
+        module.queryOne(selectNameSQL, params: [id], resolve: read.resolve, reject: read.reject)
+        let close = PromiseRecorder("close draining ordinary calls")
+        let recordClose = close.resolve
+        module.close({ value in
+            XCTAssertEqual(write.settlementCount, 1)
+            XCTAssertEqual(read.settlementCount, 1)
+            recordClose(value)
+        }, reject: close.reject)
+
+        XCTAssertTrue(try waitUntilCloseDetachesSessions())
+        XCTAssertEqual(write.settlementCount, 0)
+        XCTAssertEqual(read.settlementCount, 0)
+        XCTAssertEqual(close.settlementCount, 0)
+
+        let rejected = PromiseRecorder("ordinary call after close admission stops")
+        module.query("SELECT 1", params: [], resolve: rejected.resolve, reject: rejected.reject)
+        waitForSettlements([rejected], timeout: promptDispatchTimeout)
+        XCTAssertEqual(rejected.resolutions.count, 0)
+        XCTAssertEqual(rejected.rejections, ["NOT_CONNECTED"])
+        XCTAssertEqual(rejected.settlementCount, 1)
+        XCTAssertEqual(write.settlementCount, 0)
+        XCTAssertEqual(read.settlementCount, 0)
+        XCTAssertEqual(close.settlementCount, 0)
+
+        hold.release()
+        waitForSettlements([write, read, close], timeout: promptDispatchTimeout)
+        XCTAssertTrue(hold.heldUntilRelease)
+        XCTAssertEqual(hold.entryCount, 1)
+        subscription.cancel()
+        let row = try XCTUnwrap(try resolvedValue(read) as? [String: Any])
+        XCTAssertEqual(row["name"] as? String, "ordinary-held")
+        requireSettledOnce(activeReader.recorders + [write, read, close])
+        XCTAssertEqual(try external.names(id: id), ["ordinary-held"])
+        XCTAssertEqual(events.names, [])
+    }
+
     /// Observes an accepted commit after its durable write and before its SDK call returns.
     /// This is not a window inside SQLite COMMIT.
     func testCloseWaitsForAcceptedCommitHeldAfterDurableWrite() throws {
@@ -442,6 +670,40 @@ final class SynchroModuleTransactionTests: XCTestCase {
         XCTAssertEqual(events.names, [])
     }
 
+    func testUnsupportedCyclicSQLParametersRejectPromptlyAndSettleOnce() throws {
+        try initializeModule()
+        let cyclicArray = NSMutableArray()
+        cyclicArray.add(cyclicArray)
+        let cyclicDictionary = NSMutableDictionary()
+        cyclicDictionary["type"] = "bytes"
+        cyclicDictionary["base64"] = cyclicDictionary
+        let inputs: [(String, Any)] = [
+            ("cyclic array", cyclicArray),
+            ("cyclic dictionary", cyclicDictionary),
+        ]
+        var rejections: [PromiseRecorder] = []
+
+        for (name, value) in inputs {
+            let recorder = PromiseRecorder(name)
+            let invocationStarted = Date()
+            module.query("SELECT ?", params: [value], resolve: recorder.resolve, reject: recorder.reject)
+            XCTAssertLessThan(Date().timeIntervalSince(invocationStarted), promptDispatchTimeout, name)
+            waitForSettlements([recorder], timeout: promptDispatchTimeout)
+            rejections.append(recorder)
+        }
+
+        cyclicArray.removeAllObjects()
+        cyclicDictionary.removeAllObjects()
+        let close = try closeModule()
+        for recorder in rejections {
+            XCTAssertEqual(recorder.resolutions.count, 0, recorder.name)
+            XCTAssertEqual(recorder.rejections, ["UNKNOWN"], recorder.name)
+            XCTAssertEqual(recorder.settlementCount, 1, recorder.name)
+        }
+        requireSettledOnce([close])
+        XCTAssertEqual(events.names, [])
+    }
+
     // MARK: - Inspection snapshot
 
     func testClientStateSnapshotReadsRequestedRowsInsideReadOnlySnapshot() throws {
@@ -602,6 +864,26 @@ final class SynchroModuleTransactionTests: XCTestCase {
         requireSettledOnce([inspect, snapshot, close])
     }
 
+    // MARK: - Transaction capacity
+
+    private func holdReadTransactions(count: Int) throws -> (ids: [String], recorders: [PromiseRecorder]) {
+        var ids: [String] = []
+        var recorders: [PromiseRecorder] = []
+        for index in 0..<count {
+            let begin = settle("begin reader \(index)") {
+                module.beginReadTransaction($0.resolve, reject: $0.reject)
+            }
+            let txID = try XCTUnwrap(try resolvedValue(begin) as? String)
+            let query = settle("query reader \(index)") {
+                module.txQuery(txID, sql: "SELECT 1", params: [], resolve: $0.resolve, reject: $0.reject)
+            }
+            XCTAssertEqual((try resolvedValue(query) as? [[String: Any]])?.count, 1)
+            ids.append(txID)
+            recorders += [begin, query]
+        }
+        return (ids, recorders)
+    }
+
     // MARK: - Bridge calls
 
     private func initializeModule() throws {
@@ -623,15 +905,7 @@ final class SynchroModuleTransactionTests: XCTestCase {
     private func openExternalConnection() throws -> ExternalConnection {
         let getPath = settle("get path") { module.getPath($0.resolve, reject: $0.reject) }
         let connection = try ExternalConnection(path: try XCTUnwrap(try resolvedValue(getPath) as? String))
-        let cleanup = self.cleanup!
-        addTeardownBlock {
-            do {
-                try connection.close()
-            } catch {
-                cleanup.recordFailure()
-                XCTFail("close external connection: \(error)")
-            }
-        }
+        externalConnections.append(connection)
         return connection
     }
 
@@ -658,9 +932,7 @@ final class SynchroModuleTransactionTests: XCTestCase {
 
     private func registrySnapshot() throws -> [String] {
         let module = try XCTUnwrap(self.module)
-        module.sessionsLock.lock()
-        defer { module.sessionsLock.unlock() }
-        return Array(module.sessions.keys)
+        return module.activeTransactionIDs
     }
 
     /// Close removes every registered session under the registry lock before it waits for them.
@@ -686,6 +958,19 @@ final class SynchroModuleTransactionTests: XCTestCase {
         return recorder
     }
 
+    private func waitForSettlements(
+        _ recorders: [PromiseRecorder],
+        timeout: TimeInterval = settlementTimeout,
+        file: StaticString = #filePath,
+        line: UInt = #line
+    ) {
+        let result = XCTWaiter().wait(
+            for: recorders.map(\.firstSettlement),
+            timeout: timeout
+        )
+        XCTAssertEqual(result, .completed, "promises did not settle", file: file, line: line)
+    }
+
     private func resolvedValue(
         _ recorder: PromiseRecorder,
         file: StaticString = #filePath,