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

package/ios/TypeBridge.swift

@@ -0,0 +1,297 @@
+// Type encoding/decoding helpers between UniFFI Swift types and JS-friendly JSON.
+//
+// RN's bridge marshals only primitives, NSDictionary, NSArray, NSString, NSNumber, and
+// NSData. UniFFI types (`MessageEnvelope`, `ConversationId`, `DeviceId`, `Hlc`, etc.) are
+// pure Swift structs/classes — they need to be projected into the bridge's vocabulary
+// before they can cross to JS, and reconstructed from it on the way back.
+//
+// Encoding rule: byte fields cross as `[Int]` arrays, matching the `{_bytes: [...]}`
+// projection that the existing web/relay code already uses (just unwrapped one level
+// because RN doesn't need the wrapper). All structs become `[String: Any]` dictionaries
+// keyed by snake_case field names — JS code that received CBOR from the relay gets the
+// same shape.
+//
+// Stage 4a establishes the encoders/decoders. Stage 4b uses them in `MessagingClient.init`.
+// Stage 4c+ uses them in every method that takes/returns UniFFI types.
+//
+// Spec: docs/RN_NATIVE_BINDINGS.md (stage 4).
+
+import Foundation
+
+enum TypeBridge {
+
+    // MARK: - Bytes
+
+    static func encodeBytes(_ data: Data) -> [Int] {
+        return data.map { Int($0) }
+    }
+
+    static func decodeBytes(_ value: Any?) -> Data? {
+        guard let value, !(value is NSNull) else { return nil }
+        if let arr = value as? [NSNumber] {
+            var bytes = [UInt8](); bytes.reserveCapacity(arr.count)
+            for n in arr { bytes.append(n.uint8Value) }
+            return Data(bytes)
+        }
+        if let arr = value as? [Int] {
+            return Data(arr.map { UInt8(truncatingIfNeeded: $0) })
+        }
+        // Relay JSON projection wraps byte fields as `{_bytes: [...]}` for browser
+        // DevTools inspectability — unwrap and recurse on the inner array.
+        if let dict = value as? [String: Any], let inner = dict["_bytes"] {
+            return decodeBytes(inner)
+        }
+        return nil
+    }
+
+    static func decodeBytesOrThrow(_ value: Any?, field: String) throws -> Data {
+        guard let data = decodeBytes(value) else {
+            throw BridgeError.decodeFailure("expected bytes for field `\(field)`, got \(type(of: value))")
+        }
+        return data
+    }
+
+    // MARK: - ConversationId / DeviceId / UserId
+    //
+    // The UniFFI surface declares these as dictionaries containing a `value: bytes` field.
+    // We project them to/from JS as bare `[Int]` arrays for ergonomics — the JS user
+    // doesn't need to deal with the dictionary wrapping.
+
+    static func encodeConversationId(_ id: ConversationId) -> [Int] {
+        return encodeBytes(id.value)
+    }
+
+    static func decodeConversationId(_ value: Any?) throws -> ConversationId {
+        let data = try decodeBytesOrThrow(value, field: "conversation_id")
+        return ConversationId(value: data)
+    }
+
+    static func encodeDeviceId(_ id: DeviceId) -> [Int] {
+        return encodeBytes(id.value)
+    }
+
+    static func decodeDeviceId(_ value: Any?) throws -> DeviceId {
+        let data = try decodeBytesOrThrow(value, field: "device_id")
+        return DeviceId(value: data)
+    }
+
+    static func encodeUserId(_ id: UserId) -> [Int] {
+        return encodeBytes(id.value)
+    }
+
+    static func decodeUserId(_ value: Any?) throws -> UserId {
+        let data = try decodeBytesOrThrow(value, field: "user_id")
+        return UserId(value: data)
+    }
+
+    // MARK: - Hlc
+
+    static func encodeHlc(_ hlc: Hlc) -> [String: Any] {
+        return ["wall_ms": Int(hlc.wallMs), "logical": Int(hlc.logical)]
+    }
+
+    static func decodeHlc(_ value: Any?) throws -> Hlc {
+        guard let dict = value as? [String: Any] else {
+            throw BridgeError.decodeFailure("expected hlc dict")
+        }
+        let wallMs = (dict["wall_ms"] as? NSNumber)?.uint64Value
+            ?? UInt64(dict["wall_ms"] as? Int ?? 0)
+        let logical = (dict["logical"] as? NSNumber)?.uint32Value
+            ?? UInt32(dict["logical"] as? Int ?? 0)
+        return Hlc(wallMs: wallMs, logical: logical)
+    }
+
+    // MARK: - MessageKind
+
+    static func encodeMessageKind(_ kind: MessageKind) -> String {
+        switch kind {
+        case .application: return "Application"
+        case .commit:      return "Commit"
+        case .welcome:     return "Welcome"
+        case .proposal:    return "Proposal"
+        case .keyPackage:  return "KeyPackage"
+        }
+    }
+
+    static func decodeMessageKind(_ value: Any?) throws -> MessageKind {
+        guard let s = value as? String else {
+            throw BridgeError.decodeFailure("expected MessageKind string")
+        }
+        switch s {
+        case "Application": return .application
+        case "Commit":      return .commit
+        case "Welcome":     return .welcome
+        case "Proposal":    return .proposal
+        case "KeyPackage":  return .keyPackage
+        default:
+            throw BridgeError.decodeFailure("unknown MessageKind: \(s)")
+        }
+    }
+
+    // MARK: - MessageEnvelope
+
+    static func encodeEnvelope(_ env: MessageEnvelope) -> [String: Any] {
+        return [
+            "v":               Int(env.v),
+            "conversation_id": encodeConversationId(env.conversationId),
+            "epoch":           Int(env.epoch),
+            "kind":            encodeMessageKind(env.kind),
+            "sender_device":   encodeDeviceId(env.senderDevice),
+            "seq":             Int(env.seq),
+            "hlc":             encodeHlc(env.hlc),
+            "payload":         encodeBytes(env.payload),
+            "content_hash":    encodeBytes(env.contentHash),
+        ]
+    }
+
+    static func decodeEnvelope(_ value: Any?) throws -> MessageEnvelope {
+        guard let dict = value as? [String: Any] else {
+            throw BridgeError.decodeFailure("expected envelope dict")
+        }
+        let v = UInt8((dict["v"] as? NSNumber)?.intValue ?? (dict["v"] as? Int ?? 1))
+        let convId = try decodeConversationId(dict["conversation_id"])
+        let epoch = (dict["epoch"] as? NSNumber)?.uint64Value
+            ?? UInt64(dict["epoch"] as? Int ?? 0)
+        let kind = try decodeMessageKind(dict["kind"])
+        let senderDevice = try decodeDeviceId(dict["sender_device"])
+        let seq = (dict["seq"] as? NSNumber)?.uint64Value
+            ?? UInt64(dict["seq"] as? Int ?? 0)
+        let hlc = try decodeHlc(dict["hlc"])
+        let payload = try decodeBytesOrThrow(dict["payload"], field: "payload")
+        let contentHash = try decodeBytesOrThrow(dict["content_hash"], field: "content_hash")
+        return MessageEnvelope(
+            v: v,
+            conversationId: convId,
+            epoch: epoch,
+            kind: kind,
+            senderDevice: senderDevice,
+            seq: seq,
+            hlc: hlc,
+            payload: payload,
+            contentHash: contentHash
+        )
+    }
+
+    static func encodeEnvelopeArray(_ envs: [MessageEnvelope]) -> [[String: Any]] {
+        return envs.map { encodeEnvelope($0) }
+    }
+
+    static func decodeEnvelopeArray(_ value: Any?) throws -> [MessageEnvelope] {
+        guard let arr = value as? [[String: Any]] else {
+            throw BridgeError.decodeFailure("expected envelope array")
+        }
+        return try arr.map { try decodeEnvelope($0) }
+    }
+
+    // MARK: - IncomingMessage (output-only; we encode but never decode)
+
+    static func encodeIncomingMessage(_ msg: IncomingMessage) -> [String: Any] {
+        return [
+            "conversation_id": encodeConversationId(msg.conversationId),
+            "sender_device":   encodeDeviceId(msg.senderDevice),
+            "epoch":           Int(msg.epoch),
+            "hlc":             encodeHlc(msg.hlc),
+            "plaintext":       encodeBytes(msg.plaintext),
+            "content_hash":    encodeBytes(msg.contentHash),
+        ]
+    }
+
+    static func encodeIncomingMessageArray(_ msgs: [IncomingMessage]) -> [[String: Any]] {
+        return msgs.map { encodeIncomingMessage($0) }
+    }
+
+    // MARK: - ConversationMeta
+
+    static func encodeConversationMeta(_ m: ConversationMeta) -> [String: Any] {
+        return [
+            "id":               encodeConversationId(m.id),
+            "name":             m.name as Any? ?? NSNull(),
+            "epoch":            Int(m.epoch),
+            "member_count":     Int(m.memberCount),
+            "is_device_group":  m.isDeviceGroup,
+            "created_at_ms":    Int(m.createdAtMs),
+        ]
+    }
+
+    static func encodeConversationMetaArray(_ ms: [ConversationMeta]) -> [[String: Any]] {
+        return ms.map { encodeConversationMeta($0) }
+    }
+
+    // MARK: - DeviceInfo
+
+    static func encodeDeviceInfo(_ d: DeviceInfo) -> [String: Any] {
+        return [
+            "device_id":     encodeDeviceId(d.deviceId),
+            "user_id":       encodeUserId(d.userId),
+            "label":         d.label,
+            "created_at_ms": Int(d.createdAtMs),
+            "last_seen_ms":  Int(d.lastSeenMs),
+            "revoked":       d.revoked,
+        ]
+    }
+
+    static func encodeDeviceInfoArray(_ ds: [DeviceInfo]) -> [[String: Any]] {
+        return ds.map { encodeDeviceInfo($0) }
+    }
+
+    // MARK: - DiscoveredDevice
+
+    static func encodeDiscoveredDevice(_ d: DiscoveredDevice) -> [String: Any] {
+        return [
+            "device_id":   encodeDeviceId(d.deviceId),
+            "key_package": encodeBytes(d.keyPackage),
+        ]
+    }
+
+    static func decodeDiscoveredDevice(_ value: Any?) throws -> DiscoveredDevice {
+        guard let dict = value as? [String: Any] else {
+            throw BridgeError.decodeFailure("expected DiscoveredDevice dict")
+        }
+        let deviceId = try decodeDeviceId(dict["device_id"])
+        let keyPackage = try decodeBytesOrThrow(dict["key_package"], field: "key_package")
+        return DiscoveredDevice(deviceId: deviceId, keyPackage: keyPackage)
+    }
+
+    static func decodeDiscoveredDeviceArray(_ value: Any?) throws -> [DiscoveredDevice] {
+        guard let arr = value as? [[String: Any]] else {
+            throw BridgeError.decodeFailure("expected DiscoveredDevice array")
+        }
+        return try arr.map { try decodeDiscoveredDevice($0) }
+    }
+
+    // MARK: - LinkingTicket
+
+    static func encodeLinkingTicket(_ t: LinkingTicket) -> [String: Any] {
+        return [
+            "v":                    Int(t.v),
+            "user_id":              encodeUserId(t.userId),
+            "user_pubkey":          encodeBytes(t.userPubkey),
+            "new_device_id":        encodeDeviceId(t.newDeviceId),
+            "device_binding_sig":   encodeBytes(t.deviceBindingSig),
+            "device_group_welcome": encodeBytes(t.deviceGroupWelcome),
+            "catchup_snapshot":     encodeBytes(t.catchupSnapshot),
+        ]
+    }
+
+    static func decodeLinkingTicket(_ value: Any?) throws -> LinkingTicket {
+        guard let dict = value as? [String: Any] else {
+            throw BridgeError.decodeFailure("expected LinkingTicket dict")
+        }
+        let v = UInt8((dict["v"] as? NSNumber)?.intValue ?? (dict["v"] as? Int ?? 1))
+        let userId = try decodeUserId(dict["user_id"])
+        let userPubkey = try decodeBytesOrThrow(dict["user_pubkey"], field: "user_pubkey")
+        let newDeviceId = try decodeDeviceId(dict["new_device_id"])
+        let bindingSig = try decodeBytesOrThrow(dict["device_binding_sig"], field: "device_binding_sig")
+        let groupWelcome = try decodeBytesOrThrow(dict["device_group_welcome"], field: "device_group_welcome")
+        let snapshot = try decodeBytesOrThrow(dict["catchup_snapshot"], field: "catchup_snapshot")
+        return LinkingTicket(
+            v: v,
+            userId: userId,
+            userPubkey: userPubkey,
+            newDeviceId: newDeviceId,
+            deviceBindingSig: bindingSig,
+            deviceGroupWelcome: groupWelcome,
+            catchupSnapshot: snapshot
+        )
+    }
+}

package/ios/module.modulemap

@@ -0,0 +1,4 @@
+module pingFFI {
+    header "pingFFI.h"
+    export *
+}