Implement sendMessage & getExchanges in the tbDEX http-api (#38)

amika-sq · web-flow · commit 10daa377f809 · 2024-02-29T15:02:06.000-07:00
diff --git a/Sources/tbDEX/Common/JSON/tbDEXJSONEncoder.swift b/Sources/tbDEX/Common/JSON/tbDEXJSONEncoder.swift
@@ -5,7 +5,7 @@ public class tbDEXJSONEncoder: JSONEncoder {
     public override init() {
         super.init()
 
-        outputFormatting = .sortedKeys
+        outputFormatting = [.sortedKeys, .withoutEscapingSlashes]
         dateEncodingStrategy = .custom { date, encoder in
             var container = encoder.singleValueContainer()
             try container.encode(tbDEXDateFormatter.string(from: date))
diff --git a/Sources/tbDEX/HttpClient/HttpClient.swift b/Sources/tbDEX/HttpClient/HttpClient.swift
diff --git a/Sources/tbDEX/HttpClient/RequestToken.swift b/Sources/tbDEX/HttpClient/RequestToken.swift
@@ -0,0 +1,30 @@
+import Foundation
+import Web5
+
+/// RequestToken struct, used to access protected endpoints in the tbDEX ecosystem
+///
+/// See [spec](https://github.com/TBD54566975/tbdex/tree/main/specs/http-api#protected-endpoints) for more information.
+enum RequestToken {
+
+    /// Generate a `RequestToken`
+    /// - Parameters:
+    ///   - did: The `BearerDID` of the token creator
+    ///   - pfiDIDURI: The DID URI of the PFI that is the token receiver
+    /// - Returns: Signed request token to be included as Authorization header for sending to PFI endpoints
+    static func generate(did: BearerDID, pfiDIDURI: String) async throws -> String {
+        let now = Date()
+        let exp = now.addingTimeInterval(60)
+
+        let claims = JWT.Claims(
+            issuer: did.uri,
+            subject: nil,
+            audience: pfiDIDURI,
+            expiration: exp,
+            notBefore: nil,
+            issuedAt: now,
+            jwtID: UUID().uuidString
+        )
+
+        return try JWT.sign(did: did, claims: claims)
+    }
+}
diff --git a/Sources/tbDEX/HttpClient/tbDEXErrorResponse.swift b/Sources/tbDEX/HttpClient/tbDEXErrorResponse.swift
@@ -0,0 +1,28 @@
+import AnyCodable
+import Foundation
+
+/// Representation of an error response from the tbDEX API.
+public struct tbDEXErrorResponse: LocalizedError {
+
+    /// The error message
+    public let message: String
+
+    /// Additional details about the error
+    public let errorDetails: [ErrorDetail]?
+
+    public struct ErrorDetail: Codable {
+        let id: String?
+        let status: String?
+        let code: String?
+        let title: String?
+        let detail: String?
+        let source: Source?
+        let meta: [String: AnyCodable]?
+
+        public struct Source: Codable {
+            let pointer: String?
+            let parameter: String?
+            let header: String?
+        }
+    }
+}
diff --git a/Sources/tbDEX/HttpClient/tbDEXHttpClient.swift b/Sources/tbDEX/HttpClient/tbDEXHttpClient.swift
@@ -0,0 +1,216 @@
+import AnyCodable
+import Foundation
+import Web5
+
+public enum tbDEXHttpClient {
+
+    static let session = URLSession(configuration: .default)
+
+    /// Fetch `Offering`s from a PFI
+    /// - Parameters:
+    ///   - pfiDIDURI: The DID URI of the PFI
+    ///   - filter: A `GetOfferingFilter` to filter the results
+    /// - Returns: An array of `Offering`, matching the request
+    public static func getOfferings(
+        pfiDIDURI: String,
+        filter: GetOfferingFilter? = nil
+    ) async throws -> [Offering] {
+        guard let pfiServiceEndpoint = await getPFIServiceEndpoint(pfiDIDURI: pfiDIDURI) else {
+            throw Error(reason: "DID does not have service of type PFI")
+        }
+
+        guard var components = URLComponents(string: "\(pfiServiceEndpoint)/offerings") else {
+            throw Error(reason: "Could not create URLComponents from PFI service endpoint")
+        }
+
+        components.queryItems = filter?.queryItems()
+
+        guard let url = components.url else {
+            throw Error(reason: "Could not create URL from URLComponents")
+        }
+
+        do {
+            let response = try await URLSession.shared.data(from: url)
+            let offeringsResponse = try tbDEXJSONDecoder().decode(GetOfferingsResponse.self, from: response.0)
+
+            // Return all valid Offerings provided by the PFI, throwing away any that are invalid
+            return await validOfferings(in: offeringsResponse.data)
+        } catch {
+            throw Error(reason: "Error while fetching offerings: \(error)")
+        }
+    }
+
+    /// Sends a message to a PFI
+    /// - Parameter message: The message to send
+    public static func sendMessage<D: MessageData>(
+        message: Message<D>
+    ) async throws {
+        guard try await message.verify() else {
+            throw Error(reason: "Message signature is invalid")
+        }
+
+        let pfiDidUri = message.metadata.to
+        let exchangeID = message.metadata.exchangeID
+        let kind = message.metadata.kind
+
+        guard let pfiServiceEndpoint = await getPFIServiceEndpoint(pfiDIDURI: pfiDidUri) else {
+            throw Error(reason: "DID does not have service of type PFI")
+        }
+        guard let url = URL(string: "\(pfiServiceEndpoint)/exchanges/\(exchangeID)/\(kind.rawValue)") else {
+            throw Error(reason: "Could not create URL from PFI service endpoint")
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+
+        if case .rfq = message.metadata.kind {
+            // RFQs are special, and wrap their message in an `rfq` object.
+            request.httpBody = try tbDEXJSONEncoder().encode(["rfq": message])
+        } else {
+            // All other messages encode their messages directly to the http body
+            request.httpBody = try tbDEXJSONEncoder().encode(message)
+        }
+
+        let (data , response) = try await URLSession.shared.data(for: request)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw Error(reason: "Invalid response")
+        }
+
+        switch httpResponse.statusCode {
+        case 200...299:
+            return
+        default:
+            throw buildErrorResponse(data: data, response: httpResponse)
+        }
+    }
+
+    /// Fetches the exchanges from the PFI based
+    /// - Parameters:
+    ///   - pfiDIDURI: The PFI's DID URI
+    ///   - requesterDID: The DID of the requester
+    /// - Returns: 2D array of `AnyMessage` objects, each representing an Exchange between the requester and the PFI
+    public static func getExchanges(
+        pfiDIDURI: String,
+        requesterDID: BearerDID
+    ) async throws -> [[AnyMessage]] {
+        guard let pfiServiceEndpoint = await getPFIServiceEndpoint(pfiDIDURI: pfiDIDURI) else {
+            throw Error(reason: "DID does not have service of type PFI")
+        }
+
+        guard let url = URL(string: "\(pfiServiceEndpoint)/exchanges") else {
+            throw Error(reason: "Could not create URL from PFI service endpoint")
+        }
+
+        let requestToken = try await RequestToken.generate(did: requesterDID, pfiDIDURI: pfiDIDURI)
+
+        var request = URLRequest(url: url)
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue("Bearer \(requestToken)", forHTTPHeaderField: "Authorization")
+
+        let (data, response) = try await URLSession.shared.data(for: request)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw Error(reason: "Invalid response")
+        }
+
+        switch httpResponse.statusCode {
+        case 200...299:
+            do {
+                let exchangesResponse = try tbDEXJSONDecoder().decode(GetExchangesResponse.self, from: data)
+                return exchangesResponse.data
+            } catch {
+                throw Error(reason: "Error while decoding exchanges: \(error)")
+            }
+        default:
+            throw buildErrorResponse(data: data, response: httpResponse)
+        }
+    }
+
+    // MARK: - Decodable Response Types
+
+    struct GetOfferingsResponse: Decodable {
+        public let data: [Offering]
+    }
+
+    struct GetExchangesResponse: Decodable {
+        public let data: [[AnyMessage]]
+    }
+
+    // MARK: - Private
+
+    /// Get the PFI service endpoint
+    /// - Parameter pfiDIDURI: The PFI's DID URI
+    /// - Returns: The PFI's service endpoint (if it exists)
+    private static func getPFIServiceEndpoint(pfiDIDURI: String) async -> String? {
+        let resolutionResult = await DIDResolver.resolve(didURI: pfiDIDURI)
+        if let service = resolutionResult.didDocument?.service?.first(where: { $0.type == "PFI" }) {
+            switch service.serviceEndpoint {
+            case let .one(uri):
+                return uri
+            case let .many(uris):
+                return uris.first
+            }
+        } else {
+            return nil
+        }
+    }
+
+    /// Returns all the valid `Offering`s contained within the provided array
+    /// - Parameter offerings: The `Offering`s to verify
+    /// - Returns: An array of `Offering`s that have been verified and are valid
+    private static func validOfferings(in offerings: [Offering]) async -> [Offering] {
+        var validOfferings: [Offering] = []
+
+        for offering in offerings {
+            let isValid = (try? await offering.verify()) ?? false
+            if isValid {
+                validOfferings.append(offering)
+            } else {
+                print("Invalid offering: \(offering.metadata.id)")
+            }
+        }
+
+        return validOfferings
+    }
+
+    /// Builds an error response based on the provided HTTP response.
+    /// - Parameters:
+    ///   - data: The response received in the HTTP response from the PFI.
+    ///   - response: The HTTP response received from the PFI.
+    /// - Returns: A `tbDEXErrorResponse` containing the errors and related information extraced from
+    ///   the HTTP response.
+    private static func buildErrorResponse(
+        data: Data,
+        response: HTTPURLResponse
+    ) -> tbDEXErrorResponse {
+        let errorDetails: [tbDEXErrorResponse.ErrorDetail]?
+
+        if let responseBody = try? tbDEXJSONDecoder().decode([String: AnyCodable].self, from: data),
+           let errors = responseBody["errors"],
+           let errorsData = try? tbDEXJSONEncoder().encode(errors) {
+            errorDetails = try? tbDEXJSONDecoder().decode([tbDEXErrorResponse.ErrorDetail].self, from: errorsData)
+        } else {
+            errorDetails = nil
+        }
+        
+        return tbDEXErrorResponse(
+            message: "response status: \(response.statusCode)",
+            errorDetails: errorDetails
+        )
+    }
+}
+
+// MARK: - Errors
+
+extension tbDEXHttpClient {
+
+    public struct Error: LocalizedError {
+        let reason: String
+
+        public var errorDescription: String? {
+            return reason
+        }
+    }
+}
