@zellio/chat-react-native 0.0.0-stage → 1.0.0

package/ios/vendor/swift/ZellioChatCore/Outbox.swift

@@ -0,0 +1,223 @@
+import Foundation
+
+public enum QueueStatus: String, Codable, Equatable, Sendable { case pending, failed }
+
+public struct QueuedMessage: Codable, Equatable, Sendable {
+    public var clientMessageId: String
+    public var text: String
+    public var attachments: [Attachment]
+    public var context: ChatContext?
+    public var createdAt: Date
+    public var sequence: Int
+    public var attempts: Int
+    public var status: QueueStatus
+    public var failureReason: String?
+    public var conversationId: String?
+
+    public var attachmentIds: [String] { attachments.compactMap { $0.id } }
+
+    public func asMessage(delivery: DeliveryState) -> ChatMessage {
+        ChatMessage(serverId: nil, clientMessageId: clientMessageId, from: .visitor, text: text, attachments: attachments,
+                    createdAt: ISODate.string(createdAt), delivery: delivery, failureReason: failureReason)
+    }
+}
+
+/// The saved send queue. Order is the order the customer tapped send. Survives restarts.
+public final class OfflineQueue: @unchecked Sendable {
+    public static let expiry: TimeInterval = 24 * 60 * 60
+
+    private let storage: StorageBackend
+    private let clock: ChatClock
+    private let lock = NSLock()
+    private var items: [QueuedMessage]
+
+    public init(storage: StorageBackend, clock: ChatClock = SystemClock()) {
+        self.storage = storage
+        self.clock = clock
+        self.items = storage.load([QueuedMessage].self, StorageName.queue) ?? []
+    }
+
+    private func persist() { storage.save(items, StorageName.queue) }
+
+    public var all: [QueuedMessage] { lock.lock(); defer { lock.unlock() }; return items.sorted { $0.sequence < $1.sequence } }
+    public var pending: [QueuedMessage] { all.filter { $0.status == .pending } }
+
+    @discardableResult
+    public func enqueue(clientMessageId: String = UUID().uuidString.lowercased(), text: String, attachments: [Attachment] = [], context: ChatContext?, conversationId: String?) -> QueuedMessage {
+        lock.lock(); defer { lock.unlock() }
+        let next = (items.map { $0.sequence }.max() ?? 0) + 1
+        let item = QueuedMessage(clientMessageId: clientMessageId, text: text, attachments: attachments, context: context,
+                                 createdAt: clock.now(), sequence: next, attempts: 0, status: .pending, failureReason: nil, conversationId: conversationId)
+        items.append(item)
+        persist()
+        return item
+    }
+
+    public func item(_ clientMessageId: String) -> QueuedMessage? {
+        lock.lock(); defer { lock.unlock() }
+        return items.first { $0.clientMessageId == clientMessageId }
+    }
+
+    public func remove(_ clientMessageId: String) {
+        lock.lock(); defer { lock.unlock() }
+        items.removeAll { $0.clientMessageId == clientMessageId }
+        persist()
+    }
+
+    public func recordAttempt(_ clientMessageId: String) {
+        lock.lock(); defer { lock.unlock() }
+        if let index = items.firstIndex(where: { $0.clientMessageId == clientMessageId }) {
+            items[index].attempts += 1
+            persist()
+        }
+    }
+
+    public func markFailed(_ clientMessageId: String, reason: String) {
+        lock.lock(); defer { lock.unlock() }
+        if let index = items.firstIndex(where: { $0.clientMessageId == clientMessageId }) {
+            items[index].status = .failed
+            items[index].failureReason = reason
+            persist()
+        }
+    }
+
+    /// "Try again": back to pending in the same place. The 24 hours start again.
+    public func retry(_ clientMessageId: String) {
+        lock.lock(); defer { lock.unlock() }
+        if let index = items.firstIndex(where: { $0.clientMessageId == clientMessageId }) {
+            items[index].status = .pending
+            items[index].failureReason = nil
+            items[index].attempts = 0
+            items[index].createdAt = clock.now()
+            persist()
+        }
+    }
+
+    /// Marks pending messages older than 24 hours as failed. Returns their ids.
+    @discardableResult
+    public func expireOld() -> [String] {
+        lock.lock(); defer { lock.unlock() }
+        let now = clock.now()
+        var expired: [String] = []
+        for index in items.indices where items[index].status == .pending && now.timeIntervalSince(items[index].createdAt) >= OfflineQueue.expiry {
+            items[index].status = .failed
+            items[index].failureReason = "expired"
+            expired.append(items[index].clientMessageId)
+        }
+        if !expired.isEmpty { persist() }
+        return expired
+    }
+
+    public func clear() {
+        lock.lock(); defer { lock.unlock() }
+        items = []
+        storage.remove(StorageName.queue)
+    }
+}
+
+public enum SendOutcome: Equatable, Sendable {
+    case sent(SendReceipt)
+    case retryLater(after: TimeInterval?)
+    case failedPermanently(reason: String)
+}
+
+public enum OutboxPolicy {
+    /// 401 and 429 and 5xx and network errors wait and retry. Any other 4xx fails for good.
+    public static func classify(_ error: Error) -> SendOutcome {
+        if error is CancellationError { return .retryLater(after: nil) }
+        let mapped = ErrorPolicy.map(error)
+        guard let api = error as? ChatAPIError else {
+            switch mapped {
+            case .rateLimited(let retry): return .retryLater(after: retry)
+            case .loginNeeded, .consentRequired, .network, .cancelled: return .retryLater(after: nil)
+            case .unavailable: return .failedPermanently(reason: "unavailable")
+            default: return .retryLater(after: nil)
+            }
+        }
+        switch api {
+        case .network, .timeout, .cancelled, .decoding: return .retryLater(after: nil)
+        case .http(let status, _, let retry):
+            if status == 401 || status == 429 { return .retryLater(after: retry) }
+            if (400..<500).contains(status) { return .failedPermanently(reason: "http_\(status)") }
+            return .retryLater(after: nil)
+        }
+    }
+}
+
+/// Sends the queue in order. One drain at a time.
+public actor Outbox {
+    public enum Update: Equatable, Sendable {
+        case changed
+        case sent(clientMessageId: String, receipt: SendReceipt)
+        case failed(clientMessageId: String, reason: String)
+    }
+
+    public typealias Sender = @Sendable (QueuedMessage) async throws -> SendReceipt
+    public typealias Listener = @Sendable (Update) -> Void
+
+    public let queue: OfflineQueue
+    private let clock: ChatClock
+    private let random: RandomSource
+    private let sender: Sender
+    private var listener: Listener?
+    private var draining = false
+    private var task: Task<Void, Never>?
+    private var online = true
+
+    public init(queue: OfflineQueue, clock: ChatClock = SystemClock(), random: RandomSource = SystemRandom(), sender: @escaping Sender) {
+        self.queue = queue
+        self.clock = clock
+        self.random = random
+        self.sender = sender
+    }
+
+    public func setListener(_ listener: Listener?) { self.listener = listener }
+
+    /// Starts a drain when none runs.
+    public func kick() {
+        guard !draining else { return }
+        draining = true
+        task = Task { [weak self] in
+            await self?.drain()
+        }
+    }
+
+    public func networkReturned() { online = true; kick() }
+    public func networkLost() { online = false }
+
+    public func cancelAll() {
+        task?.cancel()
+        task = nil
+        draining = false
+    }
+
+    /// One full pass. Public so tests can await it.
+    public func drain() async {
+        defer { draining = false }
+        var waitAttempt = 0
+        while !Task.isCancelled {
+            for id in queue.expireOld() { listener?(.failed(clientMessageId: id, reason: "expired")) }
+            guard let next = queue.pending.first else { return }
+            queue.recordAttempt(next.clientMessageId)
+            do {
+                let receipt = try await sender(next)
+                queue.remove(next.clientMessageId)
+                listener?(.sent(clientMessageId: next.clientMessageId, receipt: receipt))
+                waitAttempt = 0
+            } catch {
+                switch OutboxPolicy.classify(error) {
+                case .failedPermanently(let reason):
+                    queue.markFailed(next.clientMessageId, reason: reason)
+                    listener?(.failed(clientMessageId: next.clientMessageId, reason: reason))
+                case .retryLater(let after):
+                    listener?(.changed)
+                    let delay = after ?? Backoff.delay(attempt: waitAttempt, random: random)
+                    waitAttempt += 1
+                    do { try await clock.sleep(seconds: min(delay, 300)) } catch { return }
+                case .sent:
+                    break
+                }
+            }
+        }
+    }
+}

package/ios/vendor/swift/ZellioChatCore/Push.swift

@@ -0,0 +1,74 @@
+import Foundation
+
+public struct ZellioPush: Equatable, Sendable {
+    public var version: Int
+    public var type: String
+    public var conversationId: String?
+    public var messageId: String?
+}
+
+public enum PushPayload {
+    public static let key = "zellio"
+
+    /// True only when the payload has the `zellio` key.
+    public static func isZellioPush(_ payload: [AnyHashable: Any]) -> Bool {
+        payload[key] != nil
+    }
+
+    /// Reads the `zellio` value. It is an object on APNs and a JSON string on FCM. Both work.
+    public static func parse(_ payload: [AnyHashable: Any]) -> ZellioPush? {
+        guard let raw = payload[key] else { return nil }
+        var object: [String: Any]?
+        if let dictionary = raw as? [String: Any] {
+            object = dictionary
+        } else if let dictionary = raw as? [AnyHashable: Any] {
+            var converted: [String: Any] = [:]
+            for (k, v) in dictionary { if let name = k as? String { converted[name] = v } }
+            object = converted
+        } else if let text = raw as? String, let data = text.data(using: .utf8) {
+            object = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any]
+        }
+        guard let fields = object else { return nil }
+        let version = (fields["v"] as? Int) ?? Int((fields["v"] as? String) ?? "") ?? 1
+        return ZellioPush(version: version, type: (fields["type"] as? String) ?? "message",
+                          conversationId: fields["conversationId"] as? String, messageId: fields["messageId"] as? String)
+    }
+}
+
+/// The unread number. Safe from any thread.
+public final class UnreadTracker: @unchecked Sendable {
+    private struct State {
+        var count = 0
+        var listeners: [Int: @Sendable (Int) -> Void] = [:]
+        var nextToken = 0
+    }
+    private let state = Locked(State())
+
+    public init() {}
+
+    public var count: Int { state.with { $0.count } }
+
+    public func set(_ value: Int) {
+        let clean = max(0, value)
+        let (changed, listeners): (Bool, [@Sendable (Int) -> Void]) = state.with { s in
+            let changed = s.count != clean
+            s.count = clean
+            return (changed, Array(s.listeners.values))
+        }
+        if changed { for listener in listeners { listener(clean) } }
+    }
+
+    /// Returns a token for `remove`. The listener is also called once with the current value.
+    @discardableResult
+    public func add(_ listener: @escaping @Sendable (Int) -> Void) -> Int {
+        let (token, current): (Int, Int) = state.with { s in
+            s.nextToken += 1
+            s.listeners[s.nextToken] = listener
+            return (s.nextToken, s.count)
+        }
+        listener(current)
+        return token
+    }
+
+    public func remove(_ token: Int) { state.with { $0.listeners[token] = nil } }
+}

package/ios/vendor/swift/ZellioChatCore/Realtime.swift

@@ -0,0 +1,328 @@
+import Foundation
+
+public struct SSEEvent: Equatable, Sendable {
+    public var name: String?
+    public var data: String
+    public var id: String?
+}
+
+/// Incremental server-sent events parser. Feed bytes as they arrive.
+/// Handles LF, CRLF and CR line ends, comments (`: ping`), multi-line data, and chunks that split a line or a UTF-8 character.
+public struct SSEParser: Sendable {
+    private var buffer = [UInt8]()
+    private var name: String?
+    private var dataLines = [String]()
+    private var lastId: String?
+    private var sawCR = false
+
+    public init() {}
+
+    public mutating func feed(_ data: Data) -> [SSEEvent] {
+        var events: [SSEEvent] = []
+        for byte in data {
+            if byte == 10 {                  // LF
+                if sawCR { sawCR = false; continue }   // second half of CRLF
+                finishLine(&events)
+            } else if byte == 13 {           // CR
+                sawCR = true
+                finishLine(&events)
+            } else {
+                sawCR = false
+                buffer.append(byte)
+            }
+        }
+        return events
+    }
+
+    private mutating func finishLine(_ events: inout [SSEEvent]) {
+        let line = String(decoding: buffer, as: UTF8.self)
+        buffer.removeAll(keepingCapacity: true)
+        if line.isEmpty {
+            // A blank line ends the event.
+            if !dataLines.isEmpty || name != nil {
+                events.append(SSEEvent(name: name, data: dataLines.joined(separator: "\n"), id: lastId))
+            }
+            name = nil
+            dataLines = []
+            return
+        }
+        if line.hasPrefix(":") { return }    // comment, for example ": ping"
+        var field = line
+        var value = ""
+        if let colon = line.firstIndex(of: ":") {
+            field = String(line[line.startIndex..<colon])
+            var rest = line[line.index(after: colon)...]
+            if rest.hasPrefix(" ") { rest = rest.dropFirst() }
+            value = String(rest)
+        }
+        switch field {
+        case "event": name = value
+        case "data": dataLines.append(value)
+        case "id": lastId = value
+        default: break    // retry and unknown fields are ignored
+        }
+    }
+}
+
+/// Reconnect delays: 1, 2, 4, 8, 16, then 30 seconds, each with jitter.
+public struct Backoff: Sendable {
+    public static let steps: [Double] = [1, 2, 4, 8, 16, 30]
+    public static let jitter = 0.25
+
+    /// `attempt` starts at 0. Jitter spreads the delay by plus or minus 25 percent.
+    public static func delay(attempt: Int, random: RandomSource) -> Double {
+        let base = steps[min(max(attempt, 0), steps.count - 1)]
+        let spread = (random.unit() * 2 - 1) * jitter
+        return base * (1 + spread)
+    }
+
+    public static func baseDelay(attempt: Int) -> Double { steps[min(max(attempt, 0), steps.count - 1)] }
+}
+
+public enum StreamState: Equatable, Sendable {
+    case idle
+    case connecting
+    case open
+    case waiting(attempt: Int)
+    case paused    // app is in the background
+}
+
+public enum StreamInput: Equatable, Sendable {
+    case start
+    case opened
+    case bytes
+    case ended           // closed by the server (10 minutes) or lost
+    case failed
+    case deadTimeout     // 45 s with no bytes
+    case enteredBackground
+    case enteredForeground
+    case stop
+}
+
+public enum StreamAction: Equatable, Sendable {
+    case connect
+    case closeConnection
+    case scheduleReconnect(attempt: Int)
+    /// Read /unread, then messages with `after`, then reopen the stream.
+    case catchUp
+}
+
+/// The reconnect rules as a pure function of state and input.
+public struct StreamMachine: Sendable {
+    public private(set) var state: StreamState = .idle
+    public private(set) var wanted = false
+    private var attempt = 0
+
+    public static let deadAfter: TimeInterval = 45
+
+    public init() {}
+
+    public mutating func handle(_ input: StreamInput) -> [StreamAction] {
+        switch input {
+        case .start:
+            wanted = true
+            guard state == .idle || state == .paused else { return [] }
+            attempt = 0
+            state = .connecting
+            return [.connect]
+        case .opened:
+            guard state == .connecting else { return [] }
+            attempt = 0
+            state = .open
+            return []
+        case .bytes:
+            return []
+        case .ended, .failed, .deadTimeout:
+            guard wanted, state == .connecting || state == .open else { return [] }
+            let next = attempt
+            attempt += 1
+            state = .waiting(attempt: next)
+            var actions: [StreamAction] = []
+            if input == .deadTimeout { actions.append(.closeConnection) }
+            actions.append(.scheduleReconnect(attempt: next))
+            return actions
+        case .enteredBackground:
+            guard wanted else { return [] }
+            let wasLive = state != .idle && state != .paused
+            state = .paused
+            return wasLive ? [.closeConnection] : []
+        case .enteredForeground:
+            guard wanted, state == .paused else { return [] }
+            attempt = 0
+            state = .connecting
+            return [.catchUp]
+        case .stop:
+            wanted = false
+            let wasLive = state != .idle
+            state = .idle
+            attempt = 0
+            return wasLive ? [.closeConnection] : []
+        }
+    }
+
+    /// The reconnect timer fired.
+    public mutating func reconnectTimerFired() -> [StreamAction] {
+        guard wanted, case .waiting = state else { return [] }
+        state = .connecting
+        return [.catchUp]
+    }
+}
+
+/// Runs the stream: connect, parse, reconnect with backoff, catch up after every gap.
+public actor RealtimeClient {
+    public typealias TokenSource = @Sendable () async throws -> String
+    public typealias EventHandler = @Sendable (RealtimeEvent) -> Void
+    public typealias CatchUp = @Sendable () async -> Void
+    public typealias AuthFailure = @Sendable (ChatAPIError) async -> Void
+
+    private let api: ChatAPI
+    private let clock: ChatClock
+    private let random: RandomSource
+    private let tokenSource: TokenSource
+    private let onEvent: EventHandler
+    private let catchUp: CatchUp
+    private let onFailure: AuthFailure
+    private var machine = StreamMachine()
+    private var loop: Task<Void, Never>?
+    private var generation = 0
+
+    public init(api: ChatAPI, clock: ChatClock = SystemClock(), random: RandomSource = SystemRandom(),
+                tokenSource: @escaping TokenSource, onEvent: @escaping EventHandler,
+                catchUp: @escaping CatchUp, onFailure: @escaping AuthFailure) {
+        self.api = api
+        self.clock = clock
+        self.random = random
+        self.tokenSource = tokenSource
+        self.onEvent = onEvent
+        self.catchUp = catchUp
+        self.onFailure = onFailure
+    }
+
+    public var state: StreamState { machine.state }
+
+    public func start() { apply(machine.handle(.start)) }
+    public func stop() { apply(machine.handle(.stop)) }
+    public func enteredBackground() { apply(machine.handle(.enteredBackground)) }
+    public func enteredForeground() { apply(machine.handle(.enteredForeground)) }
+
+    private func apply(_ actions: [StreamAction]) {
+        for action in actions {
+            switch action {
+            case .connect, .catchUp:
+                launch(initialDelay: 0, runCatchUp: action == .catchUp)
+            case .closeConnection:
+                generation += 1
+                loop?.cancel()
+                loop = nil
+            case .scheduleReconnect(let attempt):
+                launch(initialDelay: Backoff.delay(attempt: attempt, random: random), runCatchUp: true, fromTimer: true)
+            }
+        }
+    }
+
+    private func launch(initialDelay: Double, runCatchUp: Bool, fromTimer: Bool = false) {
+        generation += 1
+        let mine = generation
+        loop?.cancel()
+        loop = Task { [weak self] in
+            await self?.run(generation: mine, delay: initialDelay, runCatchUp: runCatchUp, fromTimer: fromTimer)
+        }
+    }
+
+    private func isCurrent(_ mine: Int) -> Bool { mine == generation && !Task.isCancelled }
+
+    private func run(generation mine: Int, delay: Double, runCatchUp: Bool, fromTimer: Bool) async {
+        if delay > 0 {
+            do { try await clock.sleep(seconds: delay) } catch { return }
+        }
+        guard isCurrent(mine) else { return }
+        if fromTimer {
+            let actions = machine.reconnectTimerFired()
+            if actions.isEmpty { return }
+        }
+        if runCatchUp { await catchUp() }
+        guard isCurrent(mine) else { return }
+
+        let token: String
+        do { token = try await tokenSource() } catch {
+            await ended(mine, input: .failed)
+            return
+        }
+        guard isCurrent(mine) else { return }
+
+        let lastByte = Locked(clock.now())
+        let dead = Locked(false)
+        let stream = api.openStream(token: token)
+        let reader: Task<ChatAPIError?, Never> = Task { [weak self, clock] in
+            var parser = SSEParser()
+            do {
+                for try await chunk in stream {
+                    lastByte.with { $0 = clock.now() }
+                    switch chunk {
+                    case .opened:
+                        await self?.opened(mine)
+                    case .data(let data):
+                        for event in parser.feed(data) {
+                            if let decoded = RealtimeEventDecoder.decode(event) { await self?.deliver(decoded, generation: mine) }
+                        }
+                    }
+                }
+                return nil as ChatAPIError?
+            } catch let error as ChatAPIError {
+                return error
+            } catch {
+                return ChatAPIError.network
+            }
+        }
+        let watchdog = Task { [clock] in
+            while !Task.isCancelled {
+                do { try await clock.sleep(seconds: 5) } catch { return }
+                let quiet = clock.now().timeIntervalSince(lastByte.snapshot)
+                if quiet >= StreamMachine.deadAfter {
+                    dead.with { $0 = true }
+                    reader.cancel()
+                    return
+                }
+            }
+        }
+        let failure = await withTaskCancellationHandler {
+            await reader.value
+        } onCancel: {
+            reader.cancel()
+        }
+        watchdog.cancel()
+        guard isCurrent(mine) else { return }
+        if let failure = failure {
+            if failure.status == 401 || failure.status == 403 || failure.status == 426 {
+                await onFailure(failure)
+            }
+            // These do not change by trying again. `start()` opens the stream later.
+            let reaction = ErrorPolicy.reaction(for: failure)
+            if reaction == .stopUnavailable || reaction == .showLoginNeeded {
+                guard isCurrent(mine) else { return }
+                apply(machine.handle(.stop))
+                return
+            }
+            if case .http(429, _, let retryAfter?) = failure, retryAfter > 0 {
+                do { try await clock.sleep(seconds: min(retryAfter, 300)) } catch { return }
+                guard isCurrent(mine) else { return }
+            }
+        }
+        await ended(mine, input: dead.snapshot ? .deadTimeout : (failure == nil ? .ended : .failed))
+    }
+
+    private func opened(_ mine: Int) {
+        guard mine == generation else { return }
+        _ = machine.handle(.opened)
+    }
+
+    private func deliver(_ event: RealtimeEvent, generation mine: Int) {
+        guard mine == generation else { return }
+        onEvent(event)
+    }
+
+    private func ended(_ mine: Int, input: StreamInput) async {
+        guard mine == generation else { return }
+        apply(machine.handle(input))
+    }
+}