ping-openmls-sdk-react-native-macos 0.2.0

package/ios/JSObserverBridge.swift

@@ -0,0 +1,35 @@
+// Bridge that implements UniFFI's `MessageObserver` protocol by emitting RN events. The
+// Rust core invokes `onApplicationMessage` / `onConversationUpdated` synchronously from
+// its async tasks; we just forward to JS via the event emitter — no continuations needed
+// because the Rust side doesn't wait for a return value.
+//
+// Same direction as Storage/Transport (Rust → JS) but simpler: fire-and-forget instead
+// of round-trip.
+//
+// Spec: docs/RN_NATIVE_BINDINGS.md (stage 4e).
+
+import Foundation
+
+public typealias ObserverEventEmitter = (_ name: String, _ body: [String: Any]) -> Void
+
+public final class JSObserverBridge: MessageObserver, @unchecked Sendable {
+
+    private let emit: ObserverEventEmitter
+
+    public init(emit: @escaping ObserverEventEmitter) {
+        self.emit = emit
+    }
+
+    // MARK: - UniFFI MessageObserver protocol conformance
+
+    public func onApplicationMessage(msg: IncomingMessage) {
+        emit("PingApplicationMessage", TypeBridge.encodeIncomingMessage(msg))
+    }
+
+    public func onConversationUpdated(id: ConversationId, newEpoch: UInt64) {
+        emit("PingConversationUpdated", [
+            "conversation_id": TypeBridge.encodeConversationId(id),
+            "new_epoch": Int(newEpoch),
+        ])
+    }
+}

package/ios/JSStorageBridge.swift

@@ -0,0 +1,135 @@
+// Bridge that implements UniFFI's `Storage` protocol by marshalling each call across
+// the Swift→JS→Swift boundary via RN's RCTEventEmitter. The Rust core (via UniFFI)
+// invokes our methods asynchronously; we suspend on a CheckedContinuation, fire an
+// event to JS, and the JS-side handler calls `PingNative.resolveStorageCall(id, value)`
+// to wake us up.
+//
+// Stage 4a wires this class to the actual UniFFI `Storage` protocol — it can now be
+// passed to `MessagingClient.init(storage: ...)` once stage 4b lands.
+//
+// Spec: docs/RN_NATIVE_BINDINGS.md (stage 4a).
+
+import Foundation
+
+/// Callback emitted by the bridge when it needs JS to handle a storage call. The
+/// implementation is expected to dispatch an RN event with `body = {id, method, args}`.
+public typealias StorageEventEmitter = (_ id: String, _ method: String, _ args: [String: Any]) -> Void
+
+/// JS-backed implementation of UniFFI's `Storage` protocol. Each call is a JS event
+/// round-trip; the Swift-side continuation is resumed from `PingNative` when the JS
+/// handler reports back.
+public final class JSStorageBridge: Storage, @unchecked Sendable {
+
+    private let emit: StorageEventEmitter
+
+    /// Pending Swift continuations keyed by call id. Mutations guarded by `lock`.
+    private var pending: [String: PendingCall] = [:]
+    private let lock = NSLock()
+
+    public init(emit: @escaping StorageEventEmitter) {
+        self.emit = emit
+    }
+
+    // MARK: - UniFFI Storage protocol conformance
+
+    public func get(namespace: String, key: String) async throws -> Data? {
+        return try await call(method: "get",
+                              args: ["namespace": namespace, "key": key],
+                              decode: { TypeBridge.decodeBytes($0) })
+    }
+
+    public func put(namespace: String, key: String, value: Data) async throws {
+        let _: Bool = try await call(method: "put",
+                                     args: ["namespace": namespace,
+                                            "key": key,
+                                            "value": TypeBridge.encodeBytes(value)],
+                                     decode: { _ in true })
+    }
+
+    public func delete(namespace: String, key: String) async throws {
+        let _: Bool = try await call(method: "delete",
+                                     args: ["namespace": namespace, "key": key],
+                                     decode: { _ in true })
+    }
+
+    public func listKeys(namespace: String, prefix: String) async throws -> [String] {
+        return try await call(method: "listKeys",
+                              args: ["namespace": namespace, "prefix": prefix],
+                              decode: { value in (value as? [String]) ?? [] })
+    }
+
+    // MARK: - JS → Swift resumption hooks (called from PingNative)
+
+    public func resolve(id: String, value: Any?) {
+        lock.lock()
+        let call = pending.removeValue(forKey: id)
+        lock.unlock()
+        call?.resume(.success(value as Any))
+    }
+
+    public func reject(id: String, message: String) {
+        lock.lock()
+        let call = pending.removeValue(forKey: id)
+        lock.unlock()
+        // Rust expects a `PingError` for storage failures. UniFFI 0.28 generates flat
+        // error variants with a labeled `message: String` associated value; we forward
+        // the JS-side message verbatim so it shows up in Rust-side logs.
+        call?.resume(.failure(PingError.Storage(message: message)))
+    }
+
+    // MARK: - Internals
+
+    private func call<T>(method: String,
+                         args: [String: Any],
+                         decode: @escaping (Any?) -> T) async throws -> T {
+        let id = UUID().uuidString
+        return try await withCheckedThrowingContinuation { continuation in
+            lock.lock()
+            pending[id] = PendingCall(continuation: ContinuationBox(decode: decode,
+                                                                    inner: continuation))
+            lock.unlock()
+            // Fire the event AFTER storing the continuation so a synchronously-resolving
+            // JS handler (unlikely but possible) doesn't race us.
+            emit(id, method, args)
+        }
+    }
+
+    /// Erased pending call — the bridge must hold heterogeneously-typed continuations.
+    private struct PendingCall {
+        let continuation: AnyContinuation
+        func resume(_ result: Result<Any?, Error>) {
+            continuation.resume(result)
+        }
+    }
+
+    private protocol AnyContinuation {
+        func resume(_ result: Result<Any?, Error>)
+    }
+
+    private struct ContinuationBox<T>: AnyContinuation {
+        let decode: (Any?) -> T
+        let inner: CheckedContinuation<T, Error>
+
+        func resume(_ result: Result<Any?, Error>) {
+            switch result {
+            case .success(let value):
+                inner.resume(returning: decode(value))
+            case .failure(let error):
+                inner.resume(throwing: error)
+            }
+        }
+    }
+}
+
+/// Bridge-internal errors. Rust expects `PingError` from Storage/Transport methods;
+/// `BridgeError` is used for cases the bridge itself produces (decode failures) before
+/// converting to `PingError.Codec`.
+public enum BridgeError: Error, CustomStringConvertible {
+    case decodeFailure(String)
+
+    public var description: String {
+        switch self {
+        case .decodeFailure(let m): return "bridge decode failure: \(m)"
+        }
+    }
+}

package/ios/JSTransportBridge.swift

@@ -0,0 +1,126 @@
+// Bridge that implements UniFFI's `Transport` protocol by marshalling each call across
+// the Swift→JS→Swift boundary. Same pattern as `JSStorageBridge`; isolated in its own
+// class so the two bridges' pending-call tables don't collide on UUIDs.
+//
+// Stage 4a wires this to the real UniFFI `Transport` protocol. Stage 4b will pass an
+// instance to `MessagingClient.init(transport: ...)`.
+//
+// Spec: docs/RN_NATIVE_BINDINGS.md (stage 4a).
+
+import Foundation
+
+public typealias TransportEventEmitter = (_ id: String, _ method: String, _ args: [String: Any]) -> Void
+
+/// JS-backed implementation of UniFFI's `Transport` protocol.
+public final class JSTransportBridge: Transport, @unchecked Sendable {
+
+    private let emit: TransportEventEmitter
+
+    private var pending: [String: PendingCall] = [:]
+    private let lock = NSLock()
+
+    public init(emit: @escaping TransportEventEmitter) {
+        self.emit = emit
+    }
+
+    // MARK: - UniFFI Transport protocol conformance
+
+    public func send(envelope: MessageEnvelope) async throws {
+        let _: Bool = try await call(method: "send",
+                                     args: ["envelope": TypeBridge.encodeEnvelope(envelope)],
+                                     decode: { _ in true })
+    }
+
+    public func fetchSince(conversationId: ConversationId,
+                           cursorToken: Data,
+                           limit: UInt32) async throws -> [MessageEnvelope] {
+        // Args match the JS-side `Transport.fetchSince(conversationIdHex, cursorBase64, limit)`
+        // signature exactly — hex + base64 strings are smaller across the bridge than byte
+        // arrays and align with what the relay's `/sync` endpoint already speaks.
+        let convHex = conversationId.value.map { String(format: "%02x", $0) }.joined()
+        let cursorB64 = cursorToken.base64EncodedString()
+        return try await call(method: "fetchSince",
+                              args: [
+                                "conversationIdHex": convHex,
+                                "cursorBase64":      cursorB64,
+                                "limit":             Int(limit),
+                              ],
+                              decode: { value in
+            // Best-effort decode; if JS returns malformed envelopes we return empty
+            // and let the SDK retry rather than throwing (resync is cheaper than crash).
+            guard let arr = value as? [[String: Any]] else { return [] }
+            return arr.compactMap { dict in
+                try? TypeBridge.decodeEnvelope(dict)
+            }
+        })
+    }
+
+    public func discoverDevices(userId: UserId) async throws -> [DiscoveredDevice] {
+        let userHex = userId.value.map { String(format: "%02x", $0) }.joined()
+        return try await call(method: "discoverDevices",
+                              args: ["userIdHex": userHex],
+                              decode: { value in
+            guard let arr = value as? [[String: Any]] else { return [] }
+            return arr.compactMap { dict in
+                try? TypeBridge.decodeDiscoveredDevice(dict)
+            }
+        })
+    }
+
+    // MARK: - JS → Swift resumption hooks
+
+    public func resolve(id: String, value: Any?) {
+        lock.lock()
+        let call = pending.removeValue(forKey: id)
+        lock.unlock()
+        call?.resume(.success(value as Any))
+    }
+
+    public func reject(id: String, message: String) {
+        lock.lock()
+        let call = pending.removeValue(forKey: id)
+        lock.unlock()
+        // See JSStorageBridge.reject — UniFFI 0.28 cases carry a labeled `message: String`.
+        call?.resume(.failure(PingError.Transport(message: message)))
+    }
+
+    // MARK: - Internals (mirror of JSStorageBridge — kept inlined for clarity over DRY)
+
+    private func call<T>(method: String,
+                         args: [String: Any],
+                         decode: @escaping (Any?) -> T) async throws -> T {
+        let id = UUID().uuidString
+        return try await withCheckedThrowingContinuation { continuation in
+            lock.lock()
+            pending[id] = PendingCall(continuation: ContinuationBox(decode: decode,
+                                                                    inner: continuation))
+            lock.unlock()
+            emit(id, method, args)
+        }
+    }
+
+    private struct PendingCall {
+        let continuation: AnyContinuation
+        func resume(_ result: Result<Any?, Error>) {
+            continuation.resume(result)
+        }
+    }
+
+    private protocol AnyContinuation {
+        func resume(_ result: Result<Any?, Error>)
+    }
+
+    private struct ContinuationBox<T>: AnyContinuation {
+        let decode: (Any?) -> T
+        let inner: CheckedContinuation<T, Error>
+
+        func resume(_ result: Result<Any?, Error>) {
+            switch result {
+            case .success(let value):
+                inner.resume(returning: decode(value))
+            case .failure(let error):
+                inner.resume(throwing: error)
+            }
+        }
+    }
+}

package/ios/PingNativeModule.m

@@ -0,0 +1,143 @@
+// Objective-C bridge that registers the `PingNative` Swift class with React Native's
+// module dispatcher. Required because RCT_EXTERN_MODULE / RCT_EXTERN_METHOD are
+// Objective-C macros — the Swift side stays pure Swift via @objc declarations.
+//
+// Adding a new method: declare it with RCT_EXTERN_METHOD here AND with @objc
+// (`@objc(name:resolver:rejecter:)`) on the Swift side.
+//
+// Spec: docs/RN_NATIVE_BINDINGS.md (stage 2).
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+// PingNative inherits from RCTEventEmitter (stage 3) so it can dispatch
+// "PingStorageCall" / "PingTransportCall" events to JS for the bridge marshalling.
+@interface RCT_EXTERN_MODULE(PingNative, RCTEventEmitter)
+
+// Stage 2 smoke test.
+RCT_EXTERN_METHOD(getWireContractVersion: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+// Stage 3: storage round-trip self-test.
+RCT_EXTERN_METHOD(testStorageRoundtrip: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+// Stage 3: JS-side resume hooks for the storage bridge.
+RCT_EXTERN_METHOD(resolveStorageCall: (NSString *)id
+                  value: (id)value
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(rejectStorageCall: (NSString *)id
+                  message: (NSString *)message
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+// Stage 3: JS-side resume hooks for the transport bridge.
+RCT_EXTERN_METHOD(resolveTransportCall: (NSString *)id
+                  value: (id)value
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(rejectTransportCall: (NSString *)id
+                  message: (NSString *)message
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+// Stage 4b: identity helper (UDL addition).
+RCT_EXTERN_METHOD(generateIdentityExport: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+// Stage 4b: MessagingClient lifecycle.
+RCT_EXTERN_METHOD(initClient: (NSString *)identityB64
+                  deviceLabel: (NSString *)deviceLabel
+                  nowMs: (double)nowMs
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getUserId: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getDeviceId: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+// Stage 4c: messaging methods.
+RCT_EXTERN_METHOD(freshKeyPackage: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(createConversation: (NSString *)name
+                  nowMs: (double)nowMs
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(joinConversation: (NSDictionary *)welcome
+                  nowMs: (double)nowMs
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(sendMessage: (NSArray *)conversationId
+                  plaintext: (NSArray *)plaintext
+                  nowMs: (double)nowMs
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(addMembers: (NSArray *)conversationId
+                  keyPackages: (NSArray *)keyPackages
+                  nowMs: (double)nowMs
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(removeMembers: (NSArray *)conversationId
+                  leafIndexes: (NSArray *)leafIndexes
+                  nowMs: (double)nowMs
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+// Stage 4d: sync methods.
+RCT_EXTERN_METHOD(processEnvelope: (NSDictionary *)envelope
+                  nowMs: (double)nowMs
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(syncConversations: (double)nowMs
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+// Stage 4e: discovery + observer.
+RCT_EXTERN_METHOD(listConversations: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(listDevices: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setObserver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+// Stage 4f: linking + revocation.
+RCT_EXTERN_METHOD(buildLinkingTicket: (NSArray *)newDeviceId
+                  newDeviceKp: (NSArray *)newDeviceKp
+                  nowMs: (double)nowMs
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(consumeLinkingTicket: (NSDictionary *)ticket
+                  nowMs: (double)nowMs
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(revokeDevice: (NSArray *)deviceId
+                  nowMs: (double)nowMs
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+// Stage 5 polish: macOS clipboard helper.
+RCT_EXTERN_METHOD(setClipboard: (NSString *)text
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+@end