Efficient JSON-toJSON transformations with spray-json

Question

I have a scenario similar to this: an Akka HTTP service calls another service and performs some transformations on its JSON response. Let's say it replaces "http" with "https" on every "link" attribute's value. Right now the implementation is something like:

  def route: Route =
    callToAnotherService(request) { eventualJsonResponse =>
      complete(
        eventualJsonResponse.flatMap(
          (jsonResponse: HttpResponse) => {
            Unmarshal(jsonResponse.entity.withContentType(MediaTypes.`application/json`))
              .to[JsValue]
              .map(replaceHttpInLinks)
              .flatMap(Marshal(_).to[ResponseEntity])
              .map(responseEntity => jsonResponse.copy(entity = responseEntity)))
          }
        )
      )
    }

The transformation method has the following signature:

def replaceHttpInLinks(jsValue: JsValue): JsValue = {
    // Recursively find "link" attributes and replace protocol
}

As you can see, the called service's JSON response is unmarshalled into a JsValue object and then this object is used to perform the changes. That response can be huge, and I'm concerned about both performance and memory consumption.

I was looking for a way of making those changes without unmarshalling the whole JSON document, and hopefully without introducing foreign libraries (Play JSON or others). I was thinking of something event based, along the lines of the old SAX API for XML. Does anyone come up with any idea to achieve it?

Answer 1

I think that with Spray is more complicated because it will try to build the JsValue from the body of the HTTPRequest. My suggestion is to use Circe and use HCursor to unmarshall manually. Take a look to some exampl here.

You can integrate circe with Akka: https://github.com/hseeberger/akka-http-json