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

package/ios/vendor/swift/ZellioChatCore/Session.swift

@@ -0,0 +1,210 @@
+import Foundation
+
+public typealias IdentityTokenProvider = @Sendable () async throws -> String
+
+public enum JWT {
+    /// The `sub` claim, read without checking the signature. The server checks it. Used to see a customer switch.
+    public static func subject(of token: String) -> String? {
+        let parts = token.split(separator: ".", omittingEmptySubsequences: false)
+        guard parts.count >= 2 else { return nil }
+        var base64 = String(parts[1]).replacingOccurrences(of: "-", with: "+").replacingOccurrences(of: "_", with: "/")
+        while base64.count % 4 != 0 { base64 += "=" }
+        guard let data = Data(base64Encoded: base64),
+              let object = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any],
+              let sub = object["sub"] as? String, !sub.isEmpty else { return nil }
+        return sub
+    }
+}
+
+private struct SessionMeta: Codable, Equatable {
+    var subject: String?       // the brand user id of the identified customer
+    var identified: Bool
+    var expiresAt: String?
+}
+
+/// Owns the session: creates it, keeps the token in the secret store, and applies the error-code rules.
+public actor SessionCoordinator {
+    public static let tokenKey = "sessionToken"
+
+    private let api: ChatAPI
+    private let secrets: SecretStore
+    private let storage: StorageBackend
+    private let clock: ChatClock
+    private let installId: String
+    private let locale: @Sendable () -> ChatLocale
+    private let allowed: @Sendable () async throws -> Void
+    private let onWipe: @Sendable () -> Void
+    private let onSessionStarted: @Sendable () -> Void
+
+    private var provider: IdentityTokenProvider?
+    private var creating: Task<String, Error>?
+
+    /// - Parameters:
+    ///   - allowed: throws before any session call when consent or config forbids it.
+    ///   - onWipe: called when local data must go (logout, customer switch).
+    ///   - onSessionStarted: called after a new token is stored. The server forgets a push token on a new session.
+    public init(api: ChatAPI, secrets: SecretStore, storage: StorageBackend, clock: ChatClock = SystemClock(), installId: String,
+                locale: @escaping @Sendable () -> ChatLocale, allowed: @escaping @Sendable () async throws -> Void = {}, onWipe: @escaping @Sendable () -> Void = {},
+                onSessionStarted: @escaping @Sendable () -> Void = {}) {
+        self.api = api
+        self.secrets = secrets
+        self.storage = storage
+        self.clock = clock
+        self.installId = installId
+        self.locale = locale
+        self.allowed = allowed
+        self.onWipe = onWipe
+        self.onSessionStarted = onSessionStarted
+    }
+
+    public func setProvider(_ provider: IdentityTokenProvider?) { self.provider = provider }
+    public var hasProvider: Bool { provider != nil }
+
+    public var token: String? {
+        guard let token = secrets.read(SessionCoordinator.tokenKey), !token.isEmpty else { return nil }
+        // No local expiry check: the server moves expiry forward on every send and does not tell the client.
+        // The token stays until the server answers CHAT_SESSION_INVALID.
+        return token
+    }
+
+    /// Forget the token, for example after the stream got a 401.
+    public func invalidateToken() { secrets.delete(SessionCoordinator.tokenKey) }
+
+    public var isIdentified: Bool { storage.load(SessionMeta.self, StorageName.session)?.identified ?? false }
+
+    /// A valid token, creating a session when needed.
+    public func ensureSession() async throws -> String {
+        if let token = token { return token }
+        return try await createSession()
+    }
+
+    private func createSession() async throws -> String {
+        if let running = creating { return try await running.value }
+        let task = Task { try await self.performCreate() }
+        creating = task
+        defer { creating = nil }
+        return try await task.value
+    }
+
+    private func performCreate() async throws -> String {
+        try await allowed()
+        var identityToken: String?
+        if let provider = provider {
+            identityToken = try await fetchIdentity(provider)
+        }
+        let previous = storage.load(SessionMeta.self, StorageName.session)
+        let subject = identityToken.flatMap { JWT.subject(of: $0) }
+        // A different customer: the logout path first.
+        if let old = previous?.subject, let new = subject, old != new {
+            if let stale = secrets.read(SessionCoordinator.tokenKey) { try? await api.logout(token: stale) }
+            await wipe()
+        }
+        do {
+            let info = try await api.createSession(installId: installId, locale: locale(), identityToken: identityToken)
+            return store(info, subject: subject, identified: identityToken != nil && info.identified)
+        } catch let error as ChatAPIError {
+            if ErrorPolicy.reaction(for: error) == .refreshIdentityOnce, let provider = provider {
+                // Get a new token once. If that fails too, the app must log in.
+                guard let fresh = try? await provider() else { throw ChatError.loginNeeded }
+                do {
+                    let info = try await api.createSession(installId: installId, locale: locale(), identityToken: fresh)
+                    return store(info, subject: JWT.subject(of: fresh), identified: info.identified)
+                } catch {
+                    throw ChatError.loginNeeded
+                }
+            }
+            throw map(error)
+        }
+    }
+
+    /// Calls the provider. A failure is tried once more; a second failure means login is needed.
+    private func fetchIdentity(_ provider: @escaping IdentityTokenProvider) async throws -> String {
+        if let token = try? await provider(), !token.isEmpty { return token }
+        if let token = try? await provider(), !token.isEmpty { return token }
+        throw ChatError.loginNeeded
+    }
+
+    private func map(_ error: ChatAPIError) -> Error {
+        switch ErrorPolicy.reaction(for: error) {
+        case .showLoginNeeded: return ChatError.loginNeeded
+        case .stopUnavailable: return ChatError.unavailable
+        default: return error
+        }
+    }
+
+    private func store(_ info: SessionInfo, subject: String?, identified: Bool) -> String {
+        secrets.write(SessionCoordinator.tokenKey, value: info.sessionToken)
+        storage.save(SessionMeta(subject: subject, identified: identified, expiresAt: info.expiresAt), StorageName.session)
+        onSessionStarted()
+        return info.sessionToken
+    }
+
+    /// Turns a guest session into a customer session. Call after `identify` when a session already exists.
+    public func identifyCurrentSession() async throws {
+        guard let provider = provider else { return }
+        let meta = storage.load(SessionMeta.self, StorageName.session)
+        guard let current = token else { return }   // no session yet: it is made with the token later
+        let identity = try await fetchIdentity(provider)
+        let subject = JWT.subject(of: identity)
+        if let old = meta?.subject, let new = subject, old != new {
+            try? await api.logout(token: current)
+            await wipe()
+            _ = try await createSession()
+            return
+        }
+        if meta?.identified == true && meta?.subject == subject { return }
+        do {
+            let info = try await api.identify(identityToken: identity, token: current)
+            _ = store(info, subject: subject, identified: true)
+        } catch let error as ChatAPIError {
+            if ErrorPolicy.reaction(for: error) == .recreateSessionThenRetry {
+                secrets.delete(SessionCoordinator.tokenKey)
+                _ = try await createSession()
+            } else {
+                throw map(error)
+            }
+        }
+    }
+
+    /// Runs a call with the session token. 401 with CHAT_SESSION_INVALID or CHAT_SESSION_REQUIRED makes a new
+    /// session and retries once. Every other error is passed on as it is.
+    public func perform<T>(_ operation: @Sendable (String) async throws -> T) async throws -> T {
+        let first = try await ensureSession()
+        do {
+            return try await operation(first)
+        } catch let error as ChatAPIError {
+            switch ErrorPolicy.reaction(for: error) {
+            case .recreateSessionThenRetry:
+                // Only the refused token goes. A parallel call may have stored a new one already: that one stays.
+                if secrets.read(SessionCoordinator.tokenKey) == first { secrets.delete(SessionCoordinator.tokenKey) }
+                let second = try await ensureSession()
+                do { return try await operation(second) } catch let again as ChatAPIError { throw mapFinal(again) }
+            default:
+                throw mapFinal(error)
+            }
+        }
+    }
+
+    private func mapFinal(_ error: ChatAPIError) -> Error {
+        switch ErrorPolicy.reaction(for: error) {
+        case .stopUnavailable: return ChatError.unavailable
+        case .showLoginNeeded: return ChatError.loginNeeded
+        default: return error
+        }
+    }
+
+    /// Ends the session. Local data goes even when the call fails.
+    public func logout() async {
+        if let token = token {
+            try? await api.logout(token: token)
+        }
+        await wipe()
+        provider = nil
+    }
+
+    private func wipe() async {
+        secrets.delete(SessionCoordinator.tokenKey)
+        storage.removeAll(keeping: StorageName.keptOnLogout)
+        onWipe()
+    }
+}

package/ios/vendor/swift/ZellioChatCore/Storage.swift

@@ -0,0 +1,201 @@
+import Foundation
+
+/// Private local storage. The app target gives a file version that is excluded from backups.
+public protocol StorageBackend: Sendable {
+    func read(_ name: String) -> Data?
+    func write(_ name: String, _ data: Data)
+    func remove(_ name: String)
+    /// Removes every entry except the listed names.
+    func removeAll(keeping: Set<String>)
+    func names() -> [String]
+}
+
+public final class MemoryStorage: StorageBackend, @unchecked Sendable {
+    private let store = Locked<[String: Data]>([:])
+    public init() {}
+    public func read(_ name: String) -> Data? { store.with { $0[name] } }
+    public func write(_ name: String, _ data: Data) { store.with { $0[name] = data } }
+    public func remove(_ name: String) { store.with { $0[name] = nil } }
+    public func removeAll(keeping: Set<String>) { store.with { dict in dict = dict.filter { keeping.contains($0.key) } } }
+    public func names() -> [String] { store.with { Array($0.keys) } }
+}
+
+public final class FileStorage: StorageBackend, @unchecked Sendable {
+    public let directory: URL
+    private let lock = NSLock()
+
+    public init(directory: URL) {
+        self.directory = directory
+        try? FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+    }
+
+    private func url(_ name: String) -> URL {
+        let safe = String(name.map { $0.isLetter || $0.isNumber || $0 == "." || $0 == "-" || $0 == "_" ? $0 : "_" })
+        return directory.appendingPathComponent(safe)
+    }
+
+    public func read(_ name: String) -> Data? {
+        lock.lock(); defer { lock.unlock() }
+        return try? Data(contentsOf: url(name))
+    }
+
+    public func write(_ name: String, _ data: Data) {
+        lock.lock(); defer { lock.unlock() }
+        try? FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        try? data.write(to: url(name), options: .atomic)
+    }
+
+    public func remove(_ name: String) {
+        lock.lock(); defer { lock.unlock() }
+        try? FileManager.default.removeItem(at: url(name))
+    }
+
+    public func removeAll(keeping: Set<String>) {
+        lock.lock(); defer { lock.unlock() }
+        let items = (try? FileManager.default.contentsOfDirectory(atPath: directory.path)) ?? []
+        for item in items where !keeping.contains(item) {
+            try? FileManager.default.removeItem(at: directory.appendingPathComponent(item))
+        }
+    }
+
+    public func names() -> [String] {
+        lock.lock(); defer { lock.unlock() }
+        return (try? FileManager.default.contentsOfDirectory(atPath: directory.path)) ?? []
+    }
+}
+
+/// The session token lives here. The app target gives a Keychain version.
+public protocol SecretStore: Sendable {
+    func read(_ key: String) -> String?
+    func write(_ key: String, value: String)
+    func delete(_ key: String)
+}
+
+public final class MemorySecretStore: SecretStore, @unchecked Sendable {
+    private let store = Locked<[String: String]>([:])
+    public init() {}
+    public func read(_ key: String) -> String? { store.with { $0[key] } }
+    public func write(_ key: String, value: String) { store.with { $0[key] = value } }
+    public func delete(_ key: String) { store.with { $0[key] = nil } }
+}
+
+extension StorageBackend {
+    /// Reads a JSON value. A file that does not decode is removed.
+    public func load<T: Decodable>(_ type: T.Type, _ name: String) -> T? {
+        guard let data = read(name) else { return nil }
+        if let value = try? JSONDecoder().decode(type, from: data) { return value }
+        remove(name)
+        return nil
+    }
+
+    public func save<T: Encodable>(_ value: T, _ name: String) {
+        if let data = try? JSONEncoder().encode(value) { write(name, data) }
+    }
+}
+
+public enum StorageName {
+    public static let installId = "install.json"
+    public static let consent = "consent.json"
+    public static let config = "config.json"
+    public static let conversations = "conversations.json"
+    public static let queue = "queue.json"
+    public static let session = "session.json"
+    public static let drafts = "drafts.json"
+    public static let push = "push.json"
+    public static func messages(_ conversationId: String) -> String { "messages-\(conversationId).json" }
+
+    /// Kept when the customer logs out: these belong to the install. Consent is not kept, because another person can use the phone.
+    public static let keptOnLogout: Set<String> = [installId, push]
+}
+
+/// The random id of this install. Resets on reinstall because it lives in app storage.
+public enum InstallId {
+    private struct Box: Codable { var id: String }
+
+    public static func load(_ storage: StorageBackend) -> String {
+        if let box = storage.load(Box.self, StorageName.installId), !box.id.isEmpty { return box.id }
+        let id = UUID().uuidString.lowercased()
+        storage.save(Box(id: id), StorageName.installId)
+        return id
+    }
+}
+
+/// Last good config, saved raw and parsed again on load.
+public struct ConfigCache: Sendable {
+    private let storage: StorageBackend
+    public init(storage: StorageBackend) { self.storage = storage }
+
+    public func save(body: Data) { storage.write(StorageName.config, body) }
+
+    public func load() -> ChatConfig? {
+        guard let body = storage.read(StorageName.config) else { return nil }
+        if let config = try? ChatConfig.parse(body) { return config }
+        storage.remove(StorageName.config)
+        return nil
+    }
+}
+
+/// Draft text by conversation. `nil` key means a new conversation.
+public struct DraftStore: Sendable {
+    private let storage: StorageBackend
+    public init(storage: StorageBackend) { self.storage = storage }
+
+    private func key(_ conversationId: String?) -> String { conversationId ?? "_new" }
+
+    public func get(_ conversationId: String?) -> String {
+        (storage.load([String: String].self, StorageName.drafts) ?? [:])[key(conversationId)] ?? ""
+    }
+
+    public func set(_ text: String, conversationId: String?) {
+        var all = storage.load([String: String].self, StorageName.drafts) ?? [:]
+        if text.isEmpty { all[key(conversationId)] = nil } else { all[key(conversationId)] = text }
+        storage.save(all, StorageName.drafts)
+    }
+}
+
+/// What a customer accepts: the consent text and the privacy link, not the rest of the published config.
+public struct ConsentTerms: Codable, Equatable, Sendable {
+    public var en: String
+    public var ar: String
+    public var privacyUrl: String
+
+    public init(behavior: Behavior) {
+        en = (behavior.consentText.en ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
+        ar = (behavior.consentText.ar ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
+        privacyUrl = (behavior.privacyUrl ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+}
+
+/// What the customer accepted on this install.
+public struct ConsentStore: Sendable {
+    private let storage: StorageBackend
+    public init(storage: StorageBackend) { self.storage = storage }
+
+    public func isAccepted(_ terms: ConsentTerms) -> Bool {
+        storage.load(ConsentTerms.self, StorageName.consent) == terms
+    }
+
+    public func accept(_ terms: ConsentTerms) {
+        storage.save(terms, StorageName.consent)
+    }
+}
+
+public enum ConsentState: Equatable, Sendable {
+    case notRequired
+    case required
+    case granted
+}
+
+public enum ConsentGate {
+    public static func state(config: ChatConfig, store: ConsentStore) -> ConsentState {
+        if !config.snapshot.behavior.consentRequired { return .notRequired }
+        // A publish that changes only a color or a label must not ask again.
+        return store.isAccepted(ConsentTerms(behavior: config.snapshot.behavior)) ? .granted : .required
+    }
+
+    /// No session, no history and no stream before Accept.
+    public static func allowsSession(config: ChatConfig?, store: ConsentStore) -> Bool {
+        guard let config = config else { return false }
+        return state(config: config, store: store) != .required
+    }
+}

package/ios/vendor/swift/ZellioChatCore/Strings.swift

@@ -0,0 +1,104 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+/// Looks up SDK strings. The table is generated from sdks/design/strings.json.
+public struct ChatStrings: Sendable {
+    public let locale: ChatLocale
+
+    public init(locale: ChatLocale) { self.locale = locale }
+
+    public func string(_ key: String) -> String {
+        let table = locale == .ar ? ChatStringTable.ar : ChatStringTable.en
+        return table[key] ?? ChatStringTable.en[key] ?? key
+    }
+
+    public static var keys: Set<String> { Set(ChatStringTable.en.keys) }
+    public static var arabicKeys: Set<String> { Set(ChatStringTable.ar.keys) }
+
+    /// "{sender}, {text}, {time}, {delivery}" for VoiceOver. Empty parts are left out.
+    public func accessibilitySummary(sender: String, text: String, time: String, delivery: String?) -> String {
+        let separator = locale == .ar ? "، " : ", "
+        return [sender, text, time, delivery ?? ""].filter { !$0.isEmpty }.joined(separator: separator)
+    }
+}
+
+public enum ChatFormat {
+    /// Latin digits in both languages, like the web widget.
+    public static func formatter(_ locale: ChatLocale) -> Locale {
+        Locale(identifier: locale == .ar ? "ar@numbers=latn" : "en_US_POSIX")
+    }
+
+    public static func time(_ date: Date, locale: ChatLocale, timeZone: TimeZone = .current) -> String {
+        let f = DateFormatter()
+        f.locale = formatter(locale)
+        f.timeZone = timeZone
+        f.dateFormat = "h:mm a"
+        return f.string(from: date)
+    }
+
+    public static func day(_ date: Date, locale: ChatLocale, timeZone: TimeZone = .current) -> String {
+        let f = DateFormatter()
+        f.locale = formatter(locale)
+        f.timeZone = timeZone
+        f.dateStyle = .medium
+        f.timeStyle = .none
+        return f.string(from: date)
+    }
+
+    /// "Today", "Yesterday", or a date.
+    public static func daySeparator(_ date: Date, now: Date, locale: ChatLocale, timeZone: TimeZone = .current) -> String {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = timeZone
+        let strings = ChatStrings(locale: locale)
+        if calendar.isDate(date, inSameDayAs: now) { return strings.string("thread.today") }
+        if let yesterday = calendar.date(byAdding: .day, value: -1, to: now), calendar.isDate(date, inSameDayAs: yesterday) {
+            return strings.string("thread.yesterday")
+        }
+        return day(date, locale: locale, timeZone: timeZone)
+    }
+
+    /// Conversation list time: the time today, "Yesterday", or a date.
+    public static func listTime(_ date: Date, now: Date, locale: ChatLocale, timeZone: TimeZone = .current) -> String {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = timeZone
+        if calendar.isDate(date, inSameDayAs: now) { return time(date, locale: locale, timeZone: timeZone) }
+        return daySeparator(date, now: now, locale: locale, timeZone: timeZone)
+    }
+
+    public static func fileSize(_ bytes: Int) -> String {
+        if bytes < 1024 { return "\(bytes) B" }
+        if bytes < 1024 * 1024 { return "\(Int((Double(bytes) / 1024).rounded())) KB" }
+        let mb = Double(bytes) / (1024 * 1024)
+        return String(format: "%.1f MB", mb)
+    }
+}
+
+/// Which language the chat shows.
+public enum LocaleChoice {
+    /// Order: the code option, then the snapshot language policy.
+    /// `option` nil means follow the device.
+    public static func choose(option: ChatLocale?, policy: LanguagePolicy?, deviceLanguageCode: String?) -> ChatLocale {
+        let device = deviceLocale(deviceLanguageCode)
+        if let option = option { return option }
+        if let policy = policy {
+            if case .single(let locale) = policy { return locale }
+            if case .both(let defaultLocale, let startIn) = policy {
+                switch startIn {
+                case "ar": return .ar
+                case "en": return .en
+                default: return device ?? defaultLocale
+                }
+            }
+        }
+        return device ?? .en
+    }
+
+    /// `ar` or `en` only. Accepts "ar-EG", "ar_EG", "EN".
+    public static func deviceLocale(_ code: String?) -> ChatLocale? {
+        guard let code = code?.lowercased() else { return nil }
+        let language = code.split(whereSeparator: { $0 == "-" || $0 == "_" }).first.map(String.init) ?? code
+        return ChatLocale(rawValue: language)
+    }
+}