Converting a `java.util.concurrent.Future` into a `scala.concurrent.Future` using a blocking execution context

JavaFutureConverter.scala

import java.util.concurrent.ExecutionException

import scala.concurrent.{ExecutionContext, ExecutionContextExecutor, Future}
import scala.concurrent.forkjoin.ForkJoinPool
import scala.util.Failure

object BlockingExecutor {

  private[this] val threadCount = 5

  private[this] implicit val executor: ExecutionContextExecutor =
    ExecutionContext.fromExecutor(new ForkJoinPool(threadCount))

  implicit def javaFuturetoScalaFuture[A](
      jf: java.util.concurrent.Future[A]
  ): Future[A] = {
    Future(jf.get()).transform {
      case Failure(e: ExecutionException) => Failure(e.getCause)
      case x                              => x
    }
  }
}