adding replyTo field in http request body to submit RFQ

CODEOWNERS

@@ -9,7 +9,7 @@
 # The format is described: https://github.blog/2017-07-06-introducing-code-owners/
 
 # These owners will be the default owners for everything in the repo.
-* @mistermoe @phoebe-lew @jiyoontbd @michaelneale @KendallWeihe @ethan-tbd @tomdaffurn @diehuxx
+* @mistermoe @phoebe-lew @jiyoontbd @michaelneale @KendallWeihe @ethan-tbd @tomdaffurn @diehuxx @kirahsapong
 
 # -----------------------------------------------
 # BELOW THIS LINE ARE TEMPLATES, UNUSED

httpclient/src/main/kotlin/tbdex/sdk/httpclient/TbdexHttpClient.kt

@@ -5,16 +5,20 @@
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.OkHttpClient
 import okhttp3.Request
+import okhttp3.RequestBody
 import okhttp3.RequestBody.Companion.toRequestBody
 import okhttp3.Response
+import tbdex.sdk.httpclient.models.CreateExchangeRequest
 import tbdex.sdk.httpclient.models.ErrorDetail
 import tbdex.sdk.httpclient.models.Exchange
 import tbdex.sdk.httpclient.models.GetExchangesFilter
 import tbdex.sdk.httpclient.models.GetOfferingsFilter
 import tbdex.sdk.httpclient.models.TbdexResponseException
 import tbdex.sdk.protocol.Validator
 import tbdex.sdk.protocol.models.Message
+import tbdex.sdk.protocol.models.MessageKind
 import tbdex.sdk.protocol.models.Offering
+import tbdex.sdk.protocol.models.Rfq
 import tbdex.sdk.protocol.serialization.Json
 import tbdex.sdk.protocol.serialization.Json.jsonMapper
 import web5.sdk.dids.Did
@@ -68,36 +72,71 @@
   }
 
   /**
-   * Sends a message to the PFI.
+   * Sends a message to the PFI. You can also use this message to create an exchange without a replyTo URL.
    *
-   * @param message The [Message] object containing the message details to be sent.
-   * @throws TbdexResponseException for request or response errors.
+   * @param message The message to send.
+   *
+   * @throws TbdexResponseException for response errors.
    */
   fun sendMessage(message: Message) {
-    Validator.validateMessage(message)
-    message.verify()
+    validateMessage(message)
 
     val pfiDid = message.metadata.to
     val exchangeId = message.metadata.exchangeId
     val kind = message.metadata.kind
 
     val pfiServiceEndpoint = getPfiServiceEndpoint(pfiDid)
-    val url = "$pfiServiceEndpoint/exchanges/$exchangeId/$kind"
+    val url: String = if (kind == MessageKind.rfq) {
+      "$pfiServiceEndpoint/exchanges/$exchangeId"
+    } else {
+      "$pfiServiceEndpoint/exchanges/$exchangeId/$kind"
+    }
 
-    val body = Json.stringify(message).toRequestBody(jsonMediaType)
+    val body: RequestBody = Json.stringify(message).toRequestBody(jsonMediaType)
 
-    val request = Request.Builder()
-      .url(url)
-      .addHeader("Content-Type", JSON_HEADER)
-      .post(body)
-      .build()
+    val request = buildRequest(url, body)
 
-    println("attempting to send message to: ${request.url}")
+    println("Attempting to send $kind message to: ${request.url}")
 
-    val response: Response = client.newCall(request).execute()
-    if (!response.isSuccessful) {
-      throw buildResponseException(response)
-    }
+    executeRequest(request)
+  }
+
+  /**
+   * Send RFQ message and include a replyTo URL for the PFI to send a callback to.
+   *
+   * @param message The message to send (is of type RFQ)
+   * @param replyTo The callback URL for PFI to send messages to.
+   *
+   * @throws TbdexResponseException for response errors.
+   *
+   */
+  fun sendMessage(message: Rfq, replyTo: String) {
+    validateMessage(message)
+
+    val pfiDid = message.metadata.to
+    val exchangeId = message.metadata.exchangeId
+
+    val pfiServiceEndpoint = getPfiServiceEndpoint(pfiDid)
+    val url = "$pfiServiceEndpoint/exchanges/$exchangeId"
+
+    val body: RequestBody = Json.stringify(CreateExchangeRequest(message, replyTo))
+      .toRequestBody(jsonMediaType)
+
+    val request = buildRequest(url, body)
+
+    println("Attempting to send Rfq message to: ${request.url}")
+
+    executeRequest(request)
+  }
+
+  /**
+   * Aliased method for sendMessage(Rfq, String) to create an exchange by sending an RFQ with a replyTo URL.
+   *
+   * @param message The message to send (is of type RFQ)
+   * @param replyTo The callback URL for PFI to send messages to.
+   */
+  fun createExchange(message: Rfq, replyTo: String) {
+    sendMessage(message, replyTo)
   }
 
   /**
@@ -208,4 +247,25 @@
       errors = errors
     )
   }
+
+  private fun validateMessage(message: Message) {
+    Validator.validateMessage(message)
+    message.verify()
+  }
+
+  private fun buildRequest(url: String, body: RequestBody): Request {
+    val request = Request.Builder()
+      .url(url)
+      .addHeader("Content-Type", JSON_HEADER)
+      .post(body)
+      .build()
+    return request
+  }
+
+  private fun executeRequest(request: Request) {
+    val response: Response = client.newCall(request).execute()
+    if (!response.isSuccessful) {
+      throw buildResponseException(response)
+    }
+  }
 }

httpclient/src/main/kotlin/tbdex/sdk/httpclient/models/CreateExchangeRequest.kt

@@ -0,0 +1,14 @@
+package tbdex.sdk.httpclient.models
+
+import tbdex.sdk.protocol.models.Rfq
+
+/**
+ * Data class used to type request body to create exchange via TbdexHttpServer.
+ *
+ * @property rfq Rfq tbdex message received.
+ * @property replyTo Optional URL to be included in the request to create exchange.
+ */
+class CreateExchangeRequest(
+  val rfq: Rfq,
+  val replyTo: String? = null
+)

httpclient/src/test/kotlin/tbdex/sdk/httpclient/E2ETest.kt

@@ -94,13 +94,14 @@ class E2ETest {
 
     val rfqData = buildRfqData(firstOfferingId, vcJwt)
     val rfq = Rfq.create(to = pfiDid, from = myDid.uri, rfqData)
+
     rfq.sign(myDid)
 
     println("Sending RFQ against first offering id: ${offerings[0].metadata.id}.")
     println("ExchangeId for the rest of this exchange is ${rfq.metadata.exchangeId}")
 
     try {
-      client.sendMessage(rfq)
+      client.createExchange(rfq, "https://tbdex.io/callback")
     } catch (e: TbdexResponseException) {
       throw AssertionError(
         "Error in sending RFQ. " +
@@ -122,6 +123,7 @@ class E2ETest {
     order.sign(myDid)
 
     println("Sending order against Quote with exchangeId of ${order.metadata.exchangeId}")
+
     try {
       client.sendMessage(order)
     } catch (e: TbdexResponseException) {

httpclient/src/test/kotlin/tbdex/sdk/httpclient/TbdexHttpClientTest.kt

@@ -89,7 +89,16 @@ class TbdexHttpClientTest {
     server.enqueue(MockResponse().setResponseCode(HttpURLConnection.HTTP_ACCEPTED))
 
     val rfq = TestData.getRfq(pfiDid.uri, TypeId.generate("offering"))
-    assertDoesNotThrow { TbdexHttpClient.sendMessage(rfq) }
+    assertDoesNotThrow { TbdexHttpClient.sendMessage(rfq, "https://tbdex.io/callback") }
+  }
+
+  @Test
+  fun `send RFQ with createExchange success via mockwebserver`() {
+
+    server.enqueue(MockResponse().setResponseCode(HttpURLConnection.HTTP_ACCEPTED))
+
+    val rfq = TestData.getRfq(pfiDid.uri, TypeId.generate("offering"))
+    assertDoesNotThrow { TbdexHttpClient.createExchange(rfq, "https://tbdex.io/callback") }
   }
 
   @Test
@@ -109,10 +118,49 @@ class TbdexHttpClientTest {
     )
 
     val mockResponseString = Json.jsonMapper.writeValueAsString(errorDetails)
-    server.enqueue(MockResponse().setBody(mockResponseString).setResponseCode(HttpURLConnection.HTTP_BAD_REQUEST))
+    server
+      .enqueue(
+        MockResponse()
+          .setBody(mockResponseString)
+          .setResponseCode(HttpURLConnection.HTTP_BAD_REQUEST)
+      )
+
+    val rfq = TestData.getRfq(pfiDid.uri, TypeId.generate("offering"))
+    val exception = assertThrows<TbdexResponseException> {
+      TbdexHttpClient.sendMessage(rfq)
+    }
+    assertEquals(1, exception.errors?.size)
+    assertEquals("400", exception.errors?.get(0)?.status)
+  }
+
+  @Test
+  fun `send RFQ with createExchange() fail via mockwebserver`() {
+    val errorDetails = mapOf(
+      "errors" to listOf(
+        ErrorDetail(
+          id = "1",
+          status = "400",
+          code = "INVALID_INPUT",
+          title = "Invalid Input",
+          detail = "The request input is invalid.",
+          source = null,
+          meta = null
+        )
+      )
+    )
+
+    val mockResponseString = Json.jsonMapper.writeValueAsString(errorDetails)
+    server
+      .enqueue(
+        MockResponse()
+          .setBody(mockResponseString)
+          .setResponseCode(HttpURLConnection.HTTP_BAD_REQUEST)
+      )
 
     val rfq = TestData.getRfq(pfiDid.uri, TypeId.generate("offering"))
-    val exception = assertThrows<TbdexResponseException> { TbdexHttpClient.sendMessage(rfq) }
+    val exception = assertThrows<TbdexResponseException> {
+      TbdexHttpClient.createExchange(rfq, "https://tbdex.io/callback")
+    }
     assertEquals(1, exception.errors?.size)
     assertEquals("400", exception.errors?.get(0)?.status)
   }
@@ -149,7 +197,9 @@ class TbdexHttpClientTest {
     val mockResponseString = Json.jsonMapper.writeValueAsString(errorDetails)
     server.enqueue(MockResponse().setBody(mockResponseString).setResponseCode(HttpURLConnection.HTTP_BAD_REQUEST))
 
-    assertThrows<TbdexResponseException> { TbdexHttpClient.getExchange(pfiDid.uri, alice, "exchange_1234") }
+    assertThrows<TbdexResponseException> {
+      TbdexHttpClient.getExchange(pfiDid.uri, alice, "exchange_1234")
+    }
   }
 
   @Test

httpserver/src/main/kotlin/tbdex/sdk/httpserver/TbdexHttpServer.kt

@@ -15,11 +15,11 @@ import io.ktor.server.routing.get
 import io.ktor.server.routing.post
 import io.ktor.server.routing.route
 import io.ktor.server.routing.routing
+import tbdex.sdk.httpserver.handlers.createExchange
 import tbdex.sdk.httpserver.handlers.getExchanges
 import tbdex.sdk.httpserver.handlers.getOfferings
 import tbdex.sdk.httpserver.handlers.submitClose
 import tbdex.sdk.httpserver.handlers.submitOrder
-import tbdex.sdk.httpserver.handlers.submitRfq
 import tbdex.sdk.httpserver.models.ExchangesApi
 import tbdex.sdk.httpserver.models.FakeExchangesApi
 import tbdex.sdk.httpserver.models.FakeOfferingsApi
@@ -98,8 +98,8 @@ class TbdexHttpServer(private val config: TbdexHttpServerConfig) {
       }
 
       route("/exchanges") {
-        post("/{exchangeId}/rfq") {
-          submitRfq(
+        post("/{exchangeId}") {
+          createExchange(
             call = call,
             offeringsApi = offeringsApi,
             exchangesApi = exchangesApi,

httpserver/src/main/kotlin/tbdex/sdk/httpserver/handlers/SubmitRfq.kt → httpserver/src/main/kotlin/tbdex/sdk/httpserver/handlers/CreateExchange.kt

@@ -14,6 +14,8 @@ import tbdex.sdk.protocol.models.Message
 import tbdex.sdk.protocol.models.MessageKind
 import tbdex.sdk.protocol.models.Offering
 import tbdex.sdk.protocol.models.Rfq
+import tbdex.sdk.protocol.serialization.Json
+import java.net.URL
 
 /**
  * Handles the submission of a Request for Quote (RFQ) through the TBDex API.
@@ -27,18 +29,34 @@ import tbdex.sdk.protocol.models.Rfq
  * @param callback An optional callback function to be invoked after processing the RFQ.
  */
 @Suppress("TooGenericExceptionCaught", "SwallowedException")
-suspend fun submitRfq(
+suspend fun createExchange(
   call: ApplicationCall,
   offeringsApi: OfferingsApi,
   exchangesApi: ExchangesApi,
   callback: SubmitCallback?
 ) {
   val message: Rfq?
-
+  val replyTo: String?
   try {
-    message = Message.parse(call.receiveText()) as Rfq
+    val requestBody = call.receiveText()
+
+    val jsonNode = Json.jsonMapper.readTree(requestBody)
+    val rfqJsonString = jsonNode["rfq"].toString()
+
+    message = Message.parse(rfqJsonString) as Rfq
+    // sets replyTo field to null if it's not present in the jsonNode.
+    // without .takeIf { !it.isNull }, jsonNode["replyTo"].asText() will set replyTo as "null" string.
+    replyTo = jsonNode["replyTo"].takeIf { !it.isNull }?.asText()
+
   } catch (e: Exception) {
-    val errorDetail = ErrorDetail(detail = "Parsing of TBDex message failed: ${e.message}")
+    val errorDetail = ErrorDetail(detail = "Parsing of TBDex createExchange request failed: ${e.message}")
+    val errorResponse = ErrorResponse(listOf(errorDetail))
+    call.respond(HttpStatusCode.BadRequest, errorResponse)
+    return
+  }
+
+  if (replyTo != null && !isValidUrl(replyTo)) {
+    val errorDetail = ErrorDetail(detail = "replyTo must be a valid URL")
     val errorResponse = ErrorResponse(listOf(errorDetail))
     call.respond(HttpStatusCode.BadRequest, errorResponse)
     return
@@ -49,7 +67,8 @@ suspend fun submitRfq(
     val errorDetail = ErrorDetail(detail = "RFQ already exists.")
     call.respond(HttpStatusCode.Conflict, ErrorResponse(listOf(errorDetail)))
     return
-  } catch (_: Exception) {
+  } catch (_: NoSuchElementException) {
+    // exchangesApi.getExchange throws if no existing exchange is found
   }
 
   val offering: Offering
@@ -84,4 +103,20 @@ suspend fun submitRfq(
   }
 
   call.respond(HttpStatusCode.Accepted)
+}
+
+/**
+ * Checks if a string is a valid URL.
+ *
+ * @param replyToUrl The string to be checked.
+ * @return boolean indicating whether the string is a valid URL.
+ */
+@Suppress("SwallowedException")
+fun isValidUrl(replyToUrl: String): Boolean {
+  return try {
+    URL(replyToUrl)
+    true
+  } catch (e: Exception) {
+    false
+  }
 }