Client.swift

import Foundation
import GraphQL

/// Client is an open-ended implementation of the client side of the protocol. It parses and adds callbacks for each type of server respose.
public actor Client<InitPayload: Equatable & Codable> {
    let messenger: Messenger

    let onConnectionError: (ConnectionErrorResponse, Client) async throws -> Void
    let onConnectionAck: (ConnectionAckResponse, Client) async throws -> Void
    let onConnectionKeepAlive: (ConnectionKeepAliveResponse, Client) async throws -> Void
    let onData: (DataResponse, Client) async throws -> Void
    let onError: (ErrorResponse, Client) async throws -> Void
    let onComplete: (CompleteResponse, Client) async throws -> Void

    let encoder = GraphQLJSONEncoder()
    let decoder = JSONDecoder()

    /// Create a new client.
    ///
    /// - Parameters:
    ///   - messenger: The messenger to bind the client to.
    ///   - onConnectionError: The callback run on receipt of a `connection_error` message
    ///   - onConnectionAck: The callback run on receipt of a `connection_ack` message
    ///   - onConnectionKeepAlive: The callback run on receipt of a `connection_ka` message
    ///   - onData: The callback run on receipt of a `data` message
    ///   - onError: The callback run on receipt of an `error` message
    ///   - onComplete: The callback run on receipt of a `complete` message
    public init(
        messenger: Messenger,
        onConnectionError: @escaping (ConnectionErrorResponse, Client) async throws -> Void = {
            _,
            _ in
        },
        onConnectionAck: @escaping (ConnectionAckResponse, Client) async throws -> Void = { _, _ in
        },
        onConnectionKeepAlive:
            @escaping (ConnectionKeepAliveResponse, Client) async throws -> Void = { _, _ in },
        onData: @escaping (DataResponse, Client) async throws -> Void = { _, _ in },
        onError: @escaping (ErrorResponse, Client) async throws -> Void = { _, _ in },
        onComplete: @escaping (CompleteResponse, Client) async throws -> Void = { _, _ in }
    ) {
        self.messenger = messenger
        self.onConnectionError = onConnectionError
        self.onConnectionAck = onConnectionAck
        self.onConnectionKeepAlive = onConnectionKeepAlive
        self.onData = onData
        self.onError = onError
        self.onComplete = onComplete
    }

    /// Listen and react to the provided async sequence of server messages. This function will block until the stream is completed.
    /// - Parameter incoming: The server message sequence that the client should react to.
    public func listen<A: AsyncSequence & Sendable>(to incoming: A) async throws
    where A.Element == Data {
        for try await message in incoming {
            try await respond(to: message)
        }
    }

    private func respond(to message: Data) async throws {
        let response: Response
        do {
            response = try decoder.decode(Response.self, from: message)
        } catch {
            try await messenger.error(.noType())
            return
        }

        switch response.type {
        case .GQL_CONNECTION_ERROR:
            let connectionErrorResponse: ConnectionErrorResponse
            do {
                connectionErrorResponse = try decoder.decode(
                    ConnectionErrorResponse.self,
                    from: message
                )
            } catch {
                try await messenger.error(
                    .invalidResponseFormat(messageType: .GQL_CONNECTION_ERROR, error: error)
                )
                return
            }
            try await onConnectionError(connectionErrorResponse, self)
        case .GQL_CONNECTION_ACK:
            let connectionAckResponse: ConnectionAckResponse
            do {
                connectionAckResponse = try decoder.decode(
                    ConnectionAckResponse.self,
                    from: message
                )
            } catch {
                try await messenger.error(
                    .invalidResponseFormat(messageType: .GQL_CONNECTION_ERROR, error: error)
                )
                return
            }
            try await onConnectionAck(connectionAckResponse, self)
        case .GQL_CONNECTION_KEEP_ALIVE:
            let connectionKeepAliveResponse: ConnectionKeepAliveResponse
            do {
                connectionKeepAliveResponse = try decoder.decode(
                    ConnectionKeepAliveResponse.self,
                    from: message
                )
            } catch {
                try await messenger.error(
                    .invalidResponseFormat(messageType: .GQL_CONNECTION_KEEP_ALIVE, error: error)
                )
                return
            }
            try await onConnectionKeepAlive(connectionKeepAliveResponse, self)
        case .GQL_DATA:
            let dataResponse: DataResponse
            do {
                dataResponse = try decoder.decode(DataResponse.self, from: message)
            } catch {
                try await messenger.error(
                    .invalidResponseFormat(messageType: .GQL_DATA, error: error)
                )
                return
            }
            try await onData(dataResponse, self)
        case .GQL_ERROR:
            let errorResponse: ErrorResponse
            do {
                errorResponse = try decoder.decode(ErrorResponse.self, from: message)
            } catch {
                try await messenger.error(
                    .invalidResponseFormat(messageType: .GQL_ERROR, error: error)
                )
                return
            }
            try await onError(errorResponse, self)
        case .GQL_COMPLETE:
            let completeResponse: CompleteResponse
            do {
                completeResponse = try decoder.decode(CompleteResponse.self, from: message)
            } catch {
                try await messenger.error(
                    .invalidResponseFormat(messageType: .GQL_COMPLETE, error: error)
                )
                return
            }
            try await onComplete(completeResponse, self)
        default:
            try await messenger.error(.invalidType())
        }
    }

    /// Send a `connection_init` request through the messenger
    public func sendConnectionInit(payload: InitPayload) async throws {
        try await messenger.send(
            encoder.encode(
                ConnectionInitRequest(
                    payload: payload
                )
            )
        )
    }

    /// Send a `start` request through the messenger
    public func sendStart(payload: GraphQLRequest, id: String) async throws {
        try await messenger.send(
            encoder.encode(
                StartRequest(
                    payload: payload,
                    id: id
                )
            )
        )
    }

    /// Send a `stop` request through the messenger
    public func sendStop(id: String) async throws {
        try await messenger.send(
            encoder.encode(
                StopRequest(
                    id: id
                )
            )
        )
    }

    /// Send a `connection_terminate` request through the messenger
    public func sendConnectionTerminate() async throws {
        try await messenger.send(
            encoder.encode(
                ConnectionTerminateRequest()
            )
        )
    }
}