Preserve relation with upstream elements in akka stream - scala

Question

I have following code sample that works fine. I want to add some changes to preserve relation between request and responce. How can I ahieve that?
Rest api flow's materialized value is NotUsed. Is it possible to somehow use Keep.both for that?
// this flow is provided by some third party library that I can't change in place
val someRestApiFlow: Flow[Int, Int, NotUsed] = Flow[Int].mapAsync(10)(x => Future(x + 1))
val digits: Source[Int, NotUsed] = Source(List(1, 2, 3))
val r = digits.via(someRestApiFlow).runForeach(println)
Result is
2
3
4
I want result to be like
1 -> 2
2 -> 3
3 -> 4

Answer 1

You can use a broadcast element to create 2 separate flows. The first output of broadcast goes through someRestApiFlow, the second output of the broadcast goes unmodified. You then zip the output of the someRestApiFlow with the second output of the broadcast flow. Doing that, you have both the input element and the result of its transformation through someRestApiFlow.
digits ---> broadcast --> someRestApiFlow ---> zip --> result
\----------------------/

Answer 2

I have also encountered this kind of cases a couple of times. The only solution I have found is creating a graph using DSL and making use of broadcast and zip stages.
import akka.actor.ActorSystem
import akka.stream.scaladsl.{Broadcast, Flow, GraphDSL, RunnableGraph, Sink, Source, Zip}
import akka.stream.{ActorMaterializer, ClosedShape}
import akka.{Done, NotUsed}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
object Main extends App {
implicit val system: ActorSystem = ActorSystem("my-system")
implicit val materializer: ActorMaterializer = ActorMaterializer()
val graph = RunnableGraph.fromGraph(GraphDSL.create() { implicit builder: GraphDSL.Builder[NotUsed] =>
import GraphDSL.Implicits._
val src: Source[Int, NotUsed] = Source(List(1, 2, 3))
val someRestApiFlow: Flow[Int, Int, NotUsed] = Flow[Int].mapAsync(10)(x => Future(x + 1))
val out: Sink[(Int, Int), Future[Done]] = Sink.foreach[(Int, Int)](println)
val bcast = builder.add(Broadcast[Int](2))
val zip = builder.add(Zip[Int, Int])
src ~> bcast ~> zip.in0
bcast ~> someRestApiFlow ~> zip.in1
zip.out ~> out
ClosedShape
})
graph.run()
}
What is being done here is we are broadcasting the input to both a zip and a custom flow, and that zip also waits for the result of that custom flow and finally merges them to send sink.