Signalbird - Swift (iOS, macOS)

https://github.com/Pariette-Inc/signalbird.sdk

dependencies: [
    .package(url: "https://github.com/Pariette-Inc/signalbird.sdk", from: "1.2.0"),
],
targets: [
    .target(name: "App", dependencies: [.product(name: "Signalbird", package: "signalbird.sdk")]),
]

import Signalbird

let client = try SignalbirdApp(config: .init(
    publicKey: "sb_public_live_…",
    chatKey: "destek",
    pushKey: "mobil"
))

let boot = try await client.bootstrap()

guard let app = boot.dictionary?["app"] as? [String: Any],
      app["chat_enabled"] as? Bool == true else {
    return   // chat is off for this app: draw nothing
}

// The visitor session: the secret is stored, so history survives the next launch
try await client.startSession(["name": "Ayşe", "email": "ayse@example.com"])

// The first message opens the conversation. The quota is spent here: per conversation.
let started = try await client.startConversation(body: "Where is my parcel?")

let conversationID = (started.dictionary?["conversation"] as? [String: Any])?["id"] as? String ?? ""

try await client.sendMessage(conversationID: conversationID, body: "Order number: 1234")

// The `after` cursor: only messages newer than this one come back
let updates = try await client.getConversation(conversationID, after: lastMessageID)

try await client.setTyping(conversationID: conversationID, isTyping: true)
try await client.markRead(conversationID: conversationID, lastMessageID: lastID)
try await client.reactToMessage(conversationID: conversationID, messageID: messageID, emoji: "👍")

// Only their own message, and only within 15 minutes of sending it
try await client.editMessage(conversationID: conversationID, messageID: messageID, body: "Correction")
try await client.deleteMessage(conversationID: conversationID, messageID: messageID)

try await client.rateConversation(conversationID, rating: 5, comment: "Thank you")
try await client.closeConversation(conversationID)

// When the user signs in, bind the visitor to the contact record
try await client.identify([
    "external_id": user.id,
    "email": user.email,
    "name": user.displayName,
    "attributes": ["plan": "pro"],
])

// On sign-out, clear the local identity; the record on the server stays
client.signOut()

func application(_ application: UIApplication,
                 didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    let token = deviceToken.map { String(format: "%02x", $0) }.joined()

    Task {
        try? await client.registerDevice(
            token: token,
            externalID: currentUser?.id,
            deviceName: UIDevice.current.name,
            appVersion: Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String
        )
    }
}

try await client.unregisterDevice(token: token)   // the record is deactivated, not deleted

struct KeychainStorage: SignalbirdStorage {
    func get(_ key: String) -> String? { /* … */ }
    func set(_ key: String, _ value: String) { /* … */ }
    func remove(_ key: String) { /* … */ }
}

let client = try SignalbirdApp(config: .init(
    publicKey: "sb_public_live_…",
    chatKey: "destek",
    pushKey: "mobil",
    locale: "en",
    storage: KeychainStorage()
))

let radio = try SignalbirdClient(config: .init(
    domainKey: ProcessInfo.processInfo.environment["SIGNALBIRD_DOMAIN_KEY"] ?? "",
    source: "api-01"
))

try await radio.critical("critical", "the payment service is not responding", [
    "service": "iyzico",
])

try await radio.batch([
    ["channel": "deploy", "message": "v2.4.0 is live", "level": "info"],
])

public struct SbResult {
    public let ok: Bool
    public let status: Int
    public let data: Any?
    public let code: String?
    public let message: String?

    public var dictionary: [String: Any]? { get }
    public var array: [[String: Any]]? { get }
    public func decode<T: Decodable>(_ type: T.Type) -> T?
}

struct ConversationResponse: Decodable {
    struct Conversation: Decodable { let id: String; let status: String }
    let conversation: Conversation
}

let parsed = updates.decode(ConversationResponse.self)